Subversion Repositories SmartDukaan

Rev

Rev 19416 | Rev 22721 | 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 
 
22717 amit.gupta 692 
  def getFofoAvailability(self, itemIds):
693 
    """
694 
    Parameters:
695 
     - itemIds
696 
    """
697 
    pass
698 
 
19413 amit.gupta 699 
  def getItemLocationAvailabilityCache(self, itemLocations):
700 
    """
701 
    Parameters:
702 
     - itemLocations
703 
    """
704 
    pass
19247 kshitij.so 705 
 
19413 amit.gupta 706 
  def getItemLocationAvailabilityCacheByItemId(self, itemIds):
707 
    """
708 
    Parameters:
709 
     - itemIds
710 
    """
711 
    pass
712 
 
19416 amit.gupta 713 
  def getItemPincodeAvailability(self, itempricing, pincode):
19413 amit.gupta 714 
    """
715 
    Parameters:
19416 amit.gupta 716 
     - itempricing
19413 amit.gupta 717 
     - pincode
718 
    """
719 
    pass
720 
 
721 
 
5944 mandeep.dh 722 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
723 
  def __init__(self, iprot, oprot=None):
724 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
725 
 
726 
  def addWarehouse(self, warehouse):
727 
    """
728 
    Parameters:
729 
     - warehouse
730 
    """
731 
    self.send_addWarehouse(warehouse)
732 
    return self.recv_addWarehouse()
733 
 
734 
  def send_addWarehouse(self, warehouse):
735 
    self._oprot.writeMessageBegin('addWarehouse', TMessageType.CALL, self._seqid)
736 
    args = addWarehouse_args()
737 
    args.warehouse = warehouse
738 
    args.write(self._oprot)
739 
    self._oprot.writeMessageEnd()
740 
    self._oprot.trans.flush()
741 
 
742 
  def recv_addWarehouse(self, ):
743 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
744 
    if mtype == TMessageType.EXCEPTION:
745 
      x = TApplicationException()
746 
      x.read(self._iprot)
747 
      self._iprot.readMessageEnd()
748 
      raise x
749 
    result = addWarehouse_result()
750 
    result.read(self._iprot)
751 
    self._iprot.readMessageEnd()
752 
    if result.success is not None:
753 
      return result.success
754 
    if result.cex is not None:
755 
      raise result.cex
756 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addWarehouse failed: unknown result");
757 
 
758 
  def addVendor(self, vendor):
759 
    """
760 
    add a new vendor
761 
 
762 
    Parameters:
763 
     - vendor
764 
    """
765 
    self.send_addVendor(vendor)
766 
    return self.recv_addVendor()
767 
 
768 
  def send_addVendor(self, vendor):
769 
    self._oprot.writeMessageBegin('addVendor', TMessageType.CALL, self._seqid)
770 
    args = addVendor_args()
771 
    args.vendor = vendor
772 
    args.write(self._oprot)
773 
    self._oprot.writeMessageEnd()
774 
    self._oprot.trans.flush()
775 
 
776 
  def recv_addVendor(self, ):
777 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
778 
    if mtype == TMessageType.EXCEPTION:
779 
      x = TApplicationException()
780 
      x.read(self._iprot)
781 
      self._iprot.readMessageEnd()
782 
      raise x
783 
    result = addVendor_result()
784 
    result.read(self._iprot)
785 
    self._iprot.readMessageEnd()
786 
    if result.success is not None:
787 
      return result.success
788 
    if result.cex is not None:
789 
      raise result.cex
790 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addVendor failed: unknown result");
791 
 
792 
  def updateInventoryHistory(self, warehouse_id, timestamp, availability):
793 
    """
794 
    Stores the incremental warehouse updates of items.
795 
 
796 
    Parameters:
797 
     - warehouse_id
798 
     - timestamp
799 
     - availability
800 
    """
801 
    self.send_updateInventoryHistory(warehouse_id, timestamp, availability)
802 
    self.recv_updateInventoryHistory()
803 
 
804 
  def send_updateInventoryHistory(self, warehouse_id, timestamp, availability):
805 
    self._oprot.writeMessageBegin('updateInventoryHistory', TMessageType.CALL, self._seqid)
806 
    args = updateInventoryHistory_args()
807 
    args.warehouse_id = warehouse_id
808 
    args.timestamp = timestamp
809 
    args.availability = availability
810 
    args.write(self._oprot)
811 
    self._oprot.writeMessageEnd()
812 
    self._oprot.trans.flush()
813 
 
814 
  def recv_updateInventoryHistory(self, ):
815 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
816 
    if mtype == TMessageType.EXCEPTION:
817 
      x = TApplicationException()
818 
      x.read(self._iprot)
819 
      self._iprot.readMessageEnd()
820 
      raise x
821 
    result = updateInventoryHistory_result()
822 
    result.read(self._iprot)
823 
    self._iprot.readMessageEnd()
824 
    if result.cex is not None:
825 
      raise result.cex
826 
    return
827 
 
828 
  def updateInventory(self, warehouse_id, timestamp, availability):
829 
    """
830 
    Stores the final inventory stocks of items.
831 
 
832 
    Parameters:
833 
     - warehouse_id
834 
     - timestamp
835 
     - availability
836 
    """
837 
    self.send_updateInventory(warehouse_id, timestamp, availability)
838 
    self.recv_updateInventory()
839 
 
840 
  def send_updateInventory(self, warehouse_id, timestamp, availability):
841 
    self._oprot.writeMessageBegin('updateInventory', TMessageType.CALL, self._seqid)
842 
    args = updateInventory_args()
843 
    args.warehouse_id = warehouse_id
844 
    args.timestamp = timestamp
845 
    args.availability = availability
846 
    args.write(self._oprot)
847 
    self._oprot.writeMessageEnd()
848 
    self._oprot.trans.flush()
849 
 
850 
  def recv_updateInventory(self, ):
851 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
852 
    if mtype == TMessageType.EXCEPTION:
853 
      x = TApplicationException()
854 
      x.read(self._iprot)
855 
      self._iprot.readMessageEnd()
856 
      raise x
857 
    result = updateInventory_result()
858 
    result.read(self._iprot)
859 
    self._iprot.readMessageEnd()
860 
    if result.cex is not None:
861 
      raise result.cex
862 
    return
863 
 
864 
  def addInventory(self, itemId, warehouseId, quantity):
865 
    """
866 
    Add the inventory to existing stock.
867 
 
868 
    Parameters:
869 
     - itemId
870 
     - warehouseId
871 
     - quantity
872 
    """
873 
    self.send_addInventory(itemId, warehouseId, quantity)
874 
    self.recv_addInventory()
875 
 
876 
  def send_addInventory(self, itemId, warehouseId, quantity):
877 
    self._oprot.writeMessageBegin('addInventory', TMessageType.CALL, self._seqid)
878 
    args = addInventory_args()
879 
    args.itemId = itemId
880 
    args.warehouseId = warehouseId
881 
    args.quantity = quantity
882 
    args.write(self._oprot)
883 
    self._oprot.writeMessageEnd()
884 
    self._oprot.trans.flush()
885 
 
886 
  def recv_addInventory(self, ):
887 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
888 
    if mtype == TMessageType.EXCEPTION:
889 
      x = TApplicationException()
890 
      x.read(self._iprot)
891 
      self._iprot.readMessageEnd()
892 
      raise x
893 
    result = addInventory_result()
894 
    result.read(self._iprot)
895 
    self._iprot.readMessageEnd()
896 
    if result.cex is not None:
897 
      raise result.cex
898 
    return
899 
 
900 
  def retireWarehouse(self, warehouse_id):
901 
    """
902 
    Parameters:
903 
     - warehouse_id
904 
    """
905 
    self.send_retireWarehouse(warehouse_id)
906 
    self.recv_retireWarehouse()
907 
 
908 
  def send_retireWarehouse(self, warehouse_id):
909 
    self._oprot.writeMessageBegin('retireWarehouse', TMessageType.CALL, self._seqid)
910 
    args = retireWarehouse_args()
911 
    args.warehouse_id = warehouse_id
912 
    args.write(self._oprot)
913 
    self._oprot.writeMessageEnd()
914 
    self._oprot.trans.flush()
915 
 
916 
  def recv_retireWarehouse(self, ):
917 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
918 
    if mtype == TMessageType.EXCEPTION:
919 
      x = TApplicationException()
920 
      x.read(self._iprot)
921 
      self._iprot.readMessageEnd()
922 
      raise x
923 
    result = retireWarehouse_result()
924 
    result.read(self._iprot)
925 
    self._iprot.readMessageEnd()
926 
    if result.cex is not None:
927 
      raise result.cex
928 
    return
929 
 
930 
  def getItemInventoryByItemId(self, item_id):
931 
    """
932 
    Parameters:
933 
     - item_id
934 
    """
935 
    self.send_getItemInventoryByItemId(item_id)
936 
    return self.recv_getItemInventoryByItemId()
937 
 
938 
  def send_getItemInventoryByItemId(self, item_id):
939 
    self._oprot.writeMessageBegin('getItemInventoryByItemId', TMessageType.CALL, self._seqid)
940 
    args = getItemInventoryByItemId_args()
941 
    args.item_id = item_id
942 
    args.write(self._oprot)
943 
    self._oprot.writeMessageEnd()
944 
    self._oprot.trans.flush()
945 
 
946 
  def recv_getItemInventoryByItemId(self, ):
947 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
948 
    if mtype == TMessageType.EXCEPTION:
949 
      x = TApplicationException()
950 
      x.read(self._iprot)
951 
      self._iprot.readMessageEnd()
952 
      raise x
953 
    result = getItemInventoryByItemId_result()
954 
    result.read(self._iprot)
955 
    self._iprot.readMessageEnd()
956 
    if result.success is not None:
957 
      return result.success
958 
    if result.cex is not None:
959 
      raise result.cex
960 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemInventoryByItemId failed: unknown result");
961 
 
962 
  def getItemAvailibilityAtWarehouse(self, warehouse_id, item_id):
963 
    """
964 
    Parameters:
965 
     - warehouse_id
966 
     - item_id
967 
    """
968 
    self.send_getItemAvailibilityAtWarehouse(warehouse_id, item_id)
969 
    return self.recv_getItemAvailibilityAtWarehouse()
970 
 
971 
  def send_getItemAvailibilityAtWarehouse(self, warehouse_id, item_id):
972 
    self._oprot.writeMessageBegin('getItemAvailibilityAtWarehouse', TMessageType.CALL, self._seqid)
973 
    args = getItemAvailibilityAtWarehouse_args()
974 
    args.warehouse_id = warehouse_id
975 
    args.item_id = item_id
976 
    args.write(self._oprot)
977 
    self._oprot.writeMessageEnd()
978 
    self._oprot.trans.flush()
979 
 
980 
  def recv_getItemAvailibilityAtWarehouse(self, ):
981 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
982 
    if mtype == TMessageType.EXCEPTION:
983 
      x = TApplicationException()
984 
      x.read(self._iprot)
985 
      self._iprot.readMessageEnd()
986 
      raise x
987 
    result = getItemAvailibilityAtWarehouse_result()
988 
    result.read(self._iprot)
989 
    self._iprot.readMessageEnd()
990 
    if result.success is not None:
991 
      return result.success
992 
    if result.cex is not None:
993 
      raise result.cex
994 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemAvailibilityAtWarehouse failed: unknown result");
995 
 
5978 rajveer 996 
  def getItemAvailabilityAtLocation(self, itemId, sourceId):
5944 mandeep.dh 997 
    """
998 
    Determines the warehouse that should be used to fulfil an order for the given item.
999 
    It first checks all the warehouses which are in the logistics location given by the
1000 
    warehouse_loc parameter. If none of the warehouses there have any inventory, then the
1001 
    preferred warehouse for the item is used.
1002 
 
1003 
    Returns an ordered list of size 4 with following elements in the given order:
1004 
    1. Id of the fulfillment warehouse which was finally picked up.
1005 
    2. Expected delay added by the category manager.
1006 
    3. Id of the billing warehouse which was finally picked up.
1007 
 
1008 
    Parameters:
1009 
     - itemId
5978 rajveer 1010 
     - sourceId
5944 mandeep.dh 1011 
    """
5978 rajveer 1012 
    self.send_getItemAvailabilityAtLocation(itemId, sourceId)
5944 mandeep.dh 1013 
    return self.recv_getItemAvailabilityAtLocation()
1014 
 
5978 rajveer 1015 
  def send_getItemAvailabilityAtLocation(self, itemId, sourceId):
5944 mandeep.dh 1016 
    self._oprot.writeMessageBegin('getItemAvailabilityAtLocation', TMessageType.CALL, self._seqid)
1017 
    args = getItemAvailabilityAtLocation_args()
1018 
    args.itemId = itemId
5978 rajveer 1019 
    args.sourceId = sourceId
5944 mandeep.dh 1020 
    args.write(self._oprot)
1021 
    self._oprot.writeMessageEnd()
1022 
    self._oprot.trans.flush()
1023 
 
1024 
  def recv_getItemAvailabilityAtLocation(self, ):
1025 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1026 
    if mtype == TMessageType.EXCEPTION:
1027 
      x = TApplicationException()
1028 
      x.read(self._iprot)
1029 
      self._iprot.readMessageEnd()
1030 
      raise x
1031 
    result = getItemAvailabilityAtLocation_result()
1032 
    result.read(self._iprot)
1033 
    self._iprot.readMessageEnd()
1034 
    if result.success is not None:
1035 
      return result.success
1036 
    if result.isex is not None:
1037 
      raise result.isex
1038 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemAvailabilityAtLocation failed: unknown result");
1039 
 
1040 
  def getAllWarehouses(self, isActive):
1041 
    """
1042 
    Parameters:
1043 
     - isActive
1044 
    """
1045 
    self.send_getAllWarehouses(isActive)
1046 
    return self.recv_getAllWarehouses()
1047 
 
1048 
  def send_getAllWarehouses(self, isActive):
1049 
    self._oprot.writeMessageBegin('getAllWarehouses', TMessageType.CALL, self._seqid)
1050 
    args = getAllWarehouses_args()
1051 
    args.isActive = isActive
1052 
    args.write(self._oprot)
1053 
    self._oprot.writeMessageEnd()
1054 
    self._oprot.trans.flush()
1055 
 
1056 
  def recv_getAllWarehouses(self, ):
1057 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1058 
    if mtype == TMessageType.EXCEPTION:
1059 
      x = TApplicationException()
1060 
      x.read(self._iprot)
1061 
      self._iprot.readMessageEnd()
1062 
      raise x
1063 
    result = getAllWarehouses_result()
1064 
    result.read(self._iprot)
1065 
    self._iprot.readMessageEnd()
1066 
    if result.success is not None:
1067 
      return result.success
1068 
    if result.cex is not None:
1069 
      raise result.cex
1070 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllWarehouses failed: unknown result");
1071 
 
1072 
  def getWarehouse(self, warehouse_id):
1073 
    """
1074 
    Returns the warehouse with the given id.
1075 
 
1076 
    Parameters:
1077 
     - warehouse_id
1078 
    """
1079 
    self.send_getWarehouse(warehouse_id)
1080 
    return self.recv_getWarehouse()
1081 
 
1082 
  def send_getWarehouse(self, warehouse_id):
1083 
    self._oprot.writeMessageBegin('getWarehouse', TMessageType.CALL, self._seqid)
1084 
    args = getWarehouse_args()
1085 
    args.warehouse_id = warehouse_id
1086 
    args.write(self._oprot)
1087 
    self._oprot.writeMessageEnd()
1088 
    self._oprot.trans.flush()
1089 
 
1090 
  def recv_getWarehouse(self, ):
1091 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1092 
    if mtype == TMessageType.EXCEPTION:
1093 
      x = TApplicationException()
1094 
      x.read(self._iprot)
1095 
      self._iprot.readMessageEnd()
1096 
      raise x
1097 
    result = getWarehouse_result()
1098 
    result.read(self._iprot)
1099 
    self._iprot.readMessageEnd()
1100 
    if result.success is not None:
1101 
      return result.success
1102 
    if result.cex is not None:
1103 
      raise result.cex
1104 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getWarehouse failed: unknown result");
1105 
 
1106 
  def getAllItemsForWarehouse(self, warehouse_id):
1107 
    """
1108 
    Parameters:
1109 
     - warehouse_id
1110 
    """
1111 
    self.send_getAllItemsForWarehouse(warehouse_id)
1112 
    return self.recv_getAllItemsForWarehouse()
1113 
 
1114 
  def send_getAllItemsForWarehouse(self, warehouse_id):
1115 
    self._oprot.writeMessageBegin('getAllItemsForWarehouse', TMessageType.CALL, self._seqid)
1116 
    args = getAllItemsForWarehouse_args()
1117 
    args.warehouse_id = warehouse_id
1118 
    args.write(self._oprot)
1119 
    self._oprot.writeMessageEnd()
1120 
    self._oprot.trans.flush()
1121 
 
1122 
  def recv_getAllItemsForWarehouse(self, ):
1123 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1124 
    if mtype == TMessageType.EXCEPTION:
1125 
      x = TApplicationException()
1126 
      x.read(self._iprot)
1127 
      self._iprot.readMessageEnd()
1128 
      raise x
1129 
    result = getAllItemsForWarehouse_result()
1130 
    result.read(self._iprot)
1131 
    self._iprot.readMessageEnd()
1132 
    if result.success is not None:
1133 
      return result.success
1134 
    if result.cex is not None:
1135 
      raise result.cex
1136 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsForWarehouse failed: unknown result");
1137 
 
5966 rajveer 1138 
  def isOrderBillable(self, itemId, warehouseId, sourceId, orderId):
5944 mandeep.dh 1139 
    """
5978 rajveer 1140 
    Depending on reservation in the table, verify if we can bill this order or not.
5966 rajveer 1141 
 
1142 
    Parameters:
1143 
     - itemId
1144 
     - warehouseId
1145 
     - sourceId
1146 
     - orderId
1147 
    """
1148 
    self.send_isOrderBillable(itemId, warehouseId, sourceId, orderId)
1149 
    return self.recv_isOrderBillable()
1150 
 
1151 
  def send_isOrderBillable(self, itemId, warehouseId, sourceId, orderId):
1152 
    self._oprot.writeMessageBegin('isOrderBillable', TMessageType.CALL, self._seqid)
1153 
    args = isOrderBillable_args()
1154 
    args.itemId = itemId
1155 
    args.warehouseId = warehouseId
1156 
    args.sourceId = sourceId
1157 
    args.orderId = orderId
1158 
    args.write(self._oprot)
1159 
    self._oprot.writeMessageEnd()
1160 
    self._oprot.trans.flush()
1161 
 
1162 
  def recv_isOrderBillable(self, ):
1163 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1164 
    if mtype == TMessageType.EXCEPTION:
1165 
      x = TApplicationException()
1166 
      x.read(self._iprot)
1167 
      self._iprot.readMessageEnd()
1168 
      raise x
1169 
    result = isOrderBillable_result()
1170 
    result.read(self._iprot)
1171 
    self._iprot.readMessageEnd()
1172 
    if result.success is not None:
1173 
      return result.success
1174 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isOrderBillable failed: unknown result");
1175 
 
1176 
  def reserveItemInWarehouse(self, itemId, warehouseId, sourceId, orderId, createdTimestamp, promisedShippingTimestamp, quantity):
1177 
    """
5944 mandeep.dh 1178 
    Increases the reservation count for an item in a warehouse. Should always succeed normally.
1179 
 
1180 
    Parameters:
1181 
     - itemId
1182 
     - warehouseId
5966 rajveer 1183 
     - sourceId
1184 
     - orderId
1185 
     - createdTimestamp
1186 
     - promisedShippingTimestamp
5944 mandeep.dh 1187 
     - quantity
1188 
    """
5966 rajveer 1189 
    self.send_reserveItemInWarehouse(itemId, warehouseId, sourceId, orderId, createdTimestamp, promisedShippingTimestamp, quantity)
5944 mandeep.dh 1190 
    return self.recv_reserveItemInWarehouse()
1191 
 
5966 rajveer 1192 
  def send_reserveItemInWarehouse(self, itemId, warehouseId, sourceId, orderId, createdTimestamp, promisedShippingTimestamp, quantity):
5944 mandeep.dh 1193 
    self._oprot.writeMessageBegin('reserveItemInWarehouse', TMessageType.CALL, self._seqid)
1194 
    args = reserveItemInWarehouse_args()
1195 
    args.itemId = itemId
1196 
    args.warehouseId = warehouseId
5966 rajveer 1197 
    args.sourceId = sourceId
1198 
    args.orderId = orderId
1199 
    args.createdTimestamp = createdTimestamp
1200 
    args.promisedShippingTimestamp = promisedShippingTimestamp
5944 mandeep.dh 1201 
    args.quantity = quantity
1202 
    args.write(self._oprot)
1203 
    self._oprot.writeMessageEnd()
1204 
    self._oprot.trans.flush()
1205 
 
1206 
  def recv_reserveItemInWarehouse(self, ):
1207 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1208 
    if mtype == TMessageType.EXCEPTION:
1209 
      x = TApplicationException()
1210 
      x.read(self._iprot)
1211 
      self._iprot.readMessageEnd()
1212 
      raise x
1213 
    result = reserveItemInWarehouse_result()
1214 
    result.read(self._iprot)
1215 
    self._iprot.readMessageEnd()
1216 
    if result.success is not None:
1217 
      return result.success
1218 
    if result.cex is not None:
1219 
      raise result.cex
1220 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reserveItemInWarehouse failed: unknown result");
1221 
 
7968 amar.kumar 1222 
  def updateReservationForOrder(self, itemId, warehouseId, sourceId, orderId, createdTimestamp, promisedShippingTimestamp, quantity):
1223 
    """
1224 
    Updates the reservation for Order
1225 
 
1226 
    Parameters:
1227 
     - itemId
1228 
     - warehouseId
1229 
     - sourceId
1230 
     - orderId
1231 
     - createdTimestamp
1232 
     - promisedShippingTimestamp
1233 
     - quantity
1234 
    """
1235 
    self.send_updateReservationForOrder(itemId, warehouseId, sourceId, orderId, createdTimestamp, promisedShippingTimestamp, quantity)
1236 
    return self.recv_updateReservationForOrder()
1237 
 
1238 
  def send_updateReservationForOrder(self, itemId, warehouseId, sourceId, orderId, createdTimestamp, promisedShippingTimestamp, quantity):
1239 
    self._oprot.writeMessageBegin('updateReservationForOrder', TMessageType.CALL, self._seqid)
1240 
    args = updateReservationForOrder_args()
1241 
    args.itemId = itemId
1242 
    args.warehouseId = warehouseId
1243 
    args.sourceId = sourceId
1244 
    args.orderId = orderId
1245 
    args.createdTimestamp = createdTimestamp
1246 
    args.promisedShippingTimestamp = promisedShippingTimestamp
1247 
    args.quantity = quantity
1248 
    args.write(self._oprot)
1249 
    self._oprot.writeMessageEnd()
1250 
    self._oprot.trans.flush()
1251 
 
1252 
  def recv_updateReservationForOrder(self, ):
1253 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1254 
    if mtype == TMessageType.EXCEPTION:
1255 
      x = TApplicationException()
1256 
      x.read(self._iprot)
1257 
      self._iprot.readMessageEnd()
1258 
      raise x
1259 
    result = updateReservationForOrder_result()
1260 
    result.read(self._iprot)
1261 
    self._iprot.readMessageEnd()
1262 
    if result.success is not None:
1263 
      return result.success
1264 
    if result.cex is not None:
1265 
      raise result.cex
1266 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateReservationForOrder failed: unknown result");
1267 
 
5966 rajveer 1268 
  def reduceReservationCount(self, itemId, warehouseId, sourceId, orderId, quantity):
5944 mandeep.dh 1269 
    """
1270 
    Decreases the reservation count for an item in a warehouse. Should always succeed normally.
1271 
 
1272 
    Parameters:
1273 
     - itemId
1274 
     - warehouseId
5966 rajveer 1275 
     - sourceId
1276 
     - orderId
5944 mandeep.dh 1277 
     - quantity
1278 
    """
5966 rajveer 1279 
    self.send_reduceReservationCount(itemId, warehouseId, sourceId, orderId, quantity)
5944 mandeep.dh 1280 
    return self.recv_reduceReservationCount()
1281 
 
5966 rajveer 1282 
  def send_reduceReservationCount(self, itemId, warehouseId, sourceId, orderId, quantity):
5944 mandeep.dh 1283 
    self._oprot.writeMessageBegin('reduceReservationCount', TMessageType.CALL, self._seqid)
1284 
    args = reduceReservationCount_args()
1285 
    args.itemId = itemId
1286 
    args.warehouseId = warehouseId
5966 rajveer 1287 
    args.sourceId = sourceId
1288 
    args.orderId = orderId
5944 mandeep.dh 1289 
    args.quantity = quantity
1290 
    args.write(self._oprot)
1291 
    self._oprot.writeMessageEnd()
1292 
    self._oprot.trans.flush()
1293 
 
1294 
  def recv_reduceReservationCount(self, ):
1295 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1296 
    if mtype == TMessageType.EXCEPTION:
1297 
      x = TApplicationException()
1298 
      x.read(self._iprot)
1299 
      self._iprot.readMessageEnd()
1300 
      raise x
1301 
    result = reduceReservationCount_result()
1302 
    result.read(self._iprot)
1303 
    self._iprot.readMessageEnd()
1304 
    if result.success is not None:
1305 
      return result.success
1306 
    if result.cex is not None:
1307 
      raise result.cex
1308 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reduceReservationCount failed: unknown result");
1309 
 
1310 
  def getItemPricing(self, itemId, vendorId):
1311 
    """
1312 
    Returns the pricing information of an item associated with the vendor of the given warehouse.
1313 
    Raises an exception if either the item, vendor or the associated pricing information can't be found.
1314 
 
1315 
    Parameters:
1316 
     - itemId
1317 
     - vendorId
1318 
    """
1319 
    self.send_getItemPricing(itemId, vendorId)
1320 
    return self.recv_getItemPricing()
1321 
 
1322 
  def send_getItemPricing(self, itemId, vendorId):
1323 
    self._oprot.writeMessageBegin('getItemPricing', TMessageType.CALL, self._seqid)
1324 
    args = getItemPricing_args()
1325 
    args.itemId = itemId
1326 
    args.vendorId = vendorId
1327 
    args.write(self._oprot)
1328 
    self._oprot.writeMessageEnd()
1329 
    self._oprot.trans.flush()
1330 
 
1331 
  def recv_getItemPricing(self, ):
1332 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1333 
    if mtype == TMessageType.EXCEPTION:
1334 
      x = TApplicationException()
1335 
      x.read(self._iprot)
1336 
      self._iprot.readMessageEnd()
1337 
      raise x
1338 
    result = getItemPricing_result()
1339 
    result.read(self._iprot)
1340 
    self._iprot.readMessageEnd()
1341 
    if result.success is not None:
1342 
      return result.success
1343 
    if result.cex is not None:
1344 
      raise result.cex
1345 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricing failed: unknown result");
1346 
 
1347 
  def getAllItemPricing(self, itemId):
1348 
    """
1349 
    Returns the list of vendor pricing information of an item.
1350 
    Raises an exception if item not found corresponding to itemId
1351 
 
1352 
    Parameters:
1353 
     - itemId
1354 
    """
1355 
    self.send_getAllItemPricing(itemId)
1356 
    return self.recv_getAllItemPricing()
1357 
 
1358 
  def send_getAllItemPricing(self, itemId):
1359 
    self._oprot.writeMessageBegin('getAllItemPricing', TMessageType.CALL, self._seqid)
1360 
    args = getAllItemPricing_args()
1361 
    args.itemId = itemId
1362 
    args.write(self._oprot)
1363 
    self._oprot.writeMessageEnd()
1364 
    self._oprot.trans.flush()
1365 
 
1366 
  def recv_getAllItemPricing(self, ):
1367 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1368 
    if mtype == TMessageType.EXCEPTION:
1369 
      x = TApplicationException()
1370 
      x.read(self._iprot)
1371 
      self._iprot.readMessageEnd()
1372 
      raise x
1373 
    result = getAllItemPricing_result()
1374 
    result.read(self._iprot)
1375 
    self._iprot.readMessageEnd()
1376 
    if result.success is not None:
1377 
      return result.success
1378 
    if result.cex is not None:
1379 
      raise result.cex
1380 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemPricing failed: unknown result");
1381 
 
1382 
  def addVendorItemPricing(self, vendorItemPricing):
1383 
    """
1384 
    Adds vendor prices corresponding to the item. If pricing already exists then updates the prices.
1385 
    Raises an exception if either the item or vendor can't be found corresponding to their ids.
1386 
 
1387 
    Parameters:
1388 
     - vendorItemPricing
1389 
    """
1390 
    self.send_addVendorItemPricing(vendorItemPricing)
1391 
    self.recv_addVendorItemPricing()
1392 
 
1393 
  def send_addVendorItemPricing(self, vendorItemPricing):
1394 
    self._oprot.writeMessageBegin('addVendorItemPricing', TMessageType.CALL, self._seqid)
1395 
    args = addVendorItemPricing_args()
1396 
    args.vendorItemPricing = vendorItemPricing
1397 
    args.write(self._oprot)
1398 
    self._oprot.writeMessageEnd()
1399 
    self._oprot.trans.flush()
1400 
 
1401 
  def recv_addVendorItemPricing(self, ):
1402 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1403 
    if mtype == TMessageType.EXCEPTION:
1404 
      x = TApplicationException()
1405 
      x.read(self._iprot)
1406 
      self._iprot.readMessageEnd()
1407 
      raise x
1408 
    result = addVendorItemPricing_result()
1409 
    result.read(self._iprot)
1410 
    self._iprot.readMessageEnd()
1411 
    if result.cex is not None:
1412 
      raise result.cex
1413 
    return
1414 
 
1415 
  def getVendor(self, vendorId):
1416 
    """
1417 
    Returns a vendor given its id
1418 
 
1419 
    Parameters:
1420 
     - vendorId
1421 
    """
1422 
    self.send_getVendor(vendorId)
1423 
    return self.recv_getVendor()
1424 
 
1425 
  def send_getVendor(self, vendorId):
1426 
    self._oprot.writeMessageBegin('getVendor', TMessageType.CALL, self._seqid)
1427 
    args = getVendor_args()
1428 
    args.vendorId = vendorId
1429 
    args.write(self._oprot)
1430 
    self._oprot.writeMessageEnd()
1431 
    self._oprot.trans.flush()
1432 
 
1433 
  def recv_getVendor(self, ):
1434 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1435 
    if mtype == TMessageType.EXCEPTION:
1436 
      x = TApplicationException()
1437 
      x.read(self._iprot)
1438 
      self._iprot.readMessageEnd()
1439 
      raise x
1440 
    result = getVendor_result()
1441 
    result.read(self._iprot)
1442 
    self._iprot.readMessageEnd()
1443 
    if result.success is not None:
1444 
      return result.success
1445 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVendor failed: unknown result");
1446 
 
1447 
  def getAllVendors(self, ):
1448 
    """
1449 
    Return list of all vendors
1450 
    """
1451 
    self.send_getAllVendors()
1452 
    return self.recv_getAllVendors()
1453 
 
1454 
  def send_getAllVendors(self, ):
1455 
    self._oprot.writeMessageBegin('getAllVendors', TMessageType.CALL, self._seqid)
1456 
    args = getAllVendors_args()
1457 
    args.write(self._oprot)
1458 
    self._oprot.writeMessageEnd()
1459 
    self._oprot.trans.flush()
1460 
 
1461 
  def recv_getAllVendors(self, ):
1462 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1463 
    if mtype == TMessageType.EXCEPTION:
1464 
      x = TApplicationException()
1465 
      x.read(self._iprot)
1466 
      self._iprot.readMessageEnd()
1467 
      raise x
1468 
    result = getAllVendors_result()
1469 
    result.read(self._iprot)
1470 
    self._iprot.readMessageEnd()
1471 
    if result.success is not None:
1472 
      return result.success
1473 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVendors failed: unknown result");
1474 
 
1475 
  def addVendorItemMapping(self, key, vendorItemMapping):
1476 
    """
1477 
    Adds VendorItemMapping. Updates VendorItemMapping if exists corresponding to the item key.
1478 
 
1479 
    Parameters:
1480 
     - key
1481 
     - vendorItemMapping
1482 
    """
1483 
    self.send_addVendorItemMapping(key, vendorItemMapping)
1484 
    self.recv_addVendorItemMapping()
1485 
 
1486 
  def send_addVendorItemMapping(self, key, vendorItemMapping):
1487 
    self._oprot.writeMessageBegin('addVendorItemMapping', TMessageType.CALL, self._seqid)
1488 
    args = addVendorItemMapping_args()
1489 
    args.key = key
1490 
    args.vendorItemMapping = vendorItemMapping
1491 
    args.write(self._oprot)
1492 
    self._oprot.writeMessageEnd()
1493 
    self._oprot.trans.flush()
1494 
 
1495 
  def recv_addVendorItemMapping(self, ):
1496 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1497 
    if mtype == TMessageType.EXCEPTION:
1498 
      x = TApplicationException()
1499 
      x.read(self._iprot)
1500 
      self._iprot.readMessageEnd()
1501 
      raise x
1502 
    result = addVendorItemMapping_result()
1503 
    result.read(self._iprot)
1504 
    self._iprot.readMessageEnd()
1505 
    if result.cex is not None:
1506 
      raise result.cex
1507 
    return
1508 
 
1509 
  def getVendorItemMappings(self, itemId):
1510 
    """
1511 
    Returns the list of vendor item mapping corresponding to itemId passed as parameter.
1512 
    Raises an exception if item not found corresponding to itemId
1513 
 
1514 
    Parameters:
1515 
     - itemId
1516 
    """
1517 
    self.send_getVendorItemMappings(itemId)
1518 
    return self.recv_getVendorItemMappings()
1519 
 
1520 
  def send_getVendorItemMappings(self, itemId):
1521 
    self._oprot.writeMessageBegin('getVendorItemMappings', TMessageType.CALL, self._seqid)
1522 
    args = getVendorItemMappings_args()
1523 
    args.itemId = itemId
1524 
    args.write(self._oprot)
1525 
    self._oprot.writeMessageEnd()
1526 
    self._oprot.trans.flush()
1527 
 
1528 
  def recv_getVendorItemMappings(self, ):
1529 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1530 
    if mtype == TMessageType.EXCEPTION:
1531 
      x = TApplicationException()
1532 
      x.read(self._iprot)
1533 
      self._iprot.readMessageEnd()
1534 
      raise x
1535 
    result = getVendorItemMappings_result()
1536 
    result.read(self._iprot)
1537 
    self._iprot.readMessageEnd()
1538 
    if result.success is not None:
1539 
      return result.success
1540 
    if result.cex is not None:
1541 
      raise result.cex
1542 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVendorItemMappings failed: unknown result");
1543 
 
1544 
  def getPendingOrdersInventory(self, vendorid):
1545 
    """
1546 
    Returns a list of inventory stock for items for which there are pending orders for the given vendor.
1547 
 
1548 
    Parameters:
1549 
     - vendorid
1550 
    """
1551 
    self.send_getPendingOrdersInventory(vendorid)
1552 
    return self.recv_getPendingOrdersInventory()
1553 
 
1554 
  def send_getPendingOrdersInventory(self, vendorid):
1555 
    self._oprot.writeMessageBegin('getPendingOrdersInventory', TMessageType.CALL, self._seqid)
1556 
    args = getPendingOrdersInventory_args()
1557 
    args.vendorid = vendorid
1558 
    args.write(self._oprot)
1559 
    self._oprot.writeMessageEnd()
1560 
    self._oprot.trans.flush()
1561 
 
1562 
  def recv_getPendingOrdersInventory(self, ):
1563 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1564 
    if mtype == TMessageType.EXCEPTION:
1565 
      x = TApplicationException()
1566 
      x.read(self._iprot)
1567 
      self._iprot.readMessageEnd()
1568 
      raise x
1569 
    result = getPendingOrdersInventory_result()
1570 
    result.read(self._iprot)
1571 
    self._iprot.readMessageEnd()
1572 
    if result.success is not None:
1573 
      return result.success
1574 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPendingOrdersInventory failed: unknown result");
1575 
 
1576 
  def getWarehouses(self, warehouseType, inventoryType, vendorId, billingWarehouseId, shippingWarehouseId):
1577 
    """
1578 
    This method returns all warehouses for a given warehosueType, inventoryType, vendor, billingWarehouse and shippingWarehouse.
1579 
    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
1580 
    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
1581 
       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
1582 
       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
1583 
 
1584 
    Parameters:
1585 
     - warehouseType
1586 
     - inventoryType
1587 
     - vendorId
1588 
     - billingWarehouseId
1589 
     - shippingWarehouseId
1590 
    """
1591 
    self.send_getWarehouses(warehouseType, inventoryType, vendorId, billingWarehouseId, shippingWarehouseId)
1592 
    return self.recv_getWarehouses()
1593 
 
1594 
  def send_getWarehouses(self, warehouseType, inventoryType, vendorId, billingWarehouseId, shippingWarehouseId):
1595 
    self._oprot.writeMessageBegin('getWarehouses', TMessageType.CALL, self._seqid)
1596 
    args = getWarehouses_args()
1597 
    args.warehouseType = warehouseType
1598 
    args.inventoryType = inventoryType
1599 
    args.vendorId = vendorId
1600 
    args.billingWarehouseId = billingWarehouseId
1601 
    args.shippingWarehouseId = shippingWarehouseId
1602 
    args.write(self._oprot)
1603 
    self._oprot.writeMessageEnd()
1604 
    self._oprot.trans.flush()
1605 
 
1606 
  def recv_getWarehouses(self, ):
1607 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1608 
    if mtype == TMessageType.EXCEPTION:
1609 
      x = TApplicationException()
1610 
      x.read(self._iprot)
1611 
      self._iprot.readMessageEnd()
1612 
      raise x
1613 
    result = getWarehouses_result()
1614 
    result.read(self._iprot)
1615 
    self._iprot.readMessageEnd()
1616 
    if result.success is not None:
1617 
      return result.success
1618 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getWarehouses failed: unknown result");
1619 
 
1620 
  def resetAvailability(self, itemKey, vendorId, quantity, warehouseId):
1621 
    """
1622 
    Resets availability of an item to the quantity mentioned in a warehouse.
1623 
 
1624 
    Parameters:
1625 
     - itemKey
1626 
     - vendorId
1627 
     - quantity
1628 
     - warehouseId
1629 
    """
1630 
    self.send_resetAvailability(itemKey, vendorId, quantity, warehouseId)
1631 
    self.recv_resetAvailability()
1632 
 
1633 
  def send_resetAvailability(self, itemKey, vendorId, quantity, warehouseId):
1634 
    self._oprot.writeMessageBegin('resetAvailability', TMessageType.CALL, self._seqid)
1635 
    args = resetAvailability_args()
1636 
    args.itemKey = itemKey
1637 
    args.vendorId = vendorId
1638 
    args.quantity = quantity
1639 
    args.warehouseId = warehouseId
1640 
    args.write(self._oprot)
1641 
    self._oprot.writeMessageEnd()
1642 
    self._oprot.trans.flush()
1643 
 
1644 
  def recv_resetAvailability(self, ):
1645 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1646 
    if mtype == TMessageType.EXCEPTION:
1647 
      x = TApplicationException()
1648 
      x.read(self._iprot)
1649 
      self._iprot.readMessageEnd()
1650 
      raise x
1651 
    result = resetAvailability_result()
1652 
    result.read(self._iprot)
1653 
    self._iprot.readMessageEnd()
1654 
    if result.cex is not None:
1655 
      raise result.cex
1656 
    return
1657 
 
1658 
  def resetAvailabilityForWarehouse(self, warehouseId):
1659 
    """
1660 
    Resets availability of a warehouse to zero.
1661 
 
1662 
    Parameters:
1663 
     - warehouseId
1664 
    """
1665 
    self.send_resetAvailabilityForWarehouse(warehouseId)
1666 
    self.recv_resetAvailabilityForWarehouse()
1667 
 
1668 
  def send_resetAvailabilityForWarehouse(self, warehouseId):
1669 
    self._oprot.writeMessageBegin('resetAvailabilityForWarehouse', TMessageType.CALL, self._seqid)
1670 
    args = resetAvailabilityForWarehouse_args()
1671 
    args.warehouseId = warehouseId
1672 
    args.write(self._oprot)
1673 
    self._oprot.writeMessageEnd()
1674 
    self._oprot.trans.flush()
1675 
 
1676 
  def recv_resetAvailabilityForWarehouse(self, ):
1677 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1678 
    if mtype == TMessageType.EXCEPTION:
1679 
      x = TApplicationException()
1680 
      x.read(self._iprot)
1681 
      self._iprot.readMessageEnd()
1682 
      raise x
1683 
    result = resetAvailabilityForWarehouse_result()
1684 
    result.read(self._iprot)
1685 
    self._iprot.readMessageEnd()
1686 
    if result.cex is not None:
1687 
      raise result.cex
1688 
    return
1689 
 
1690 
  def getItemKeysToBeProcessed(self, warehouseId):
1691 
    """
1692 
    Returns the list of item keys which need to be processed for a given warehouse.
1693 
    This is currently used by Support application to send item keys whose inventory needs
1694 
    to be updated from PLB
1695 
 
1696 
    Parameters:
1697 
     - warehouseId
1698 
    """
1699 
    self.send_getItemKeysToBeProcessed(warehouseId)
1700 
    return self.recv_getItemKeysToBeProcessed()
1701 
 
1702 
  def send_getItemKeysToBeProcessed(self, warehouseId):
1703 
    self._oprot.writeMessageBegin('getItemKeysToBeProcessed', TMessageType.CALL, self._seqid)
1704 
    args = getItemKeysToBeProcessed_args()
1705 
    args.warehouseId = warehouseId
1706 
    args.write(self._oprot)
1707 
    self._oprot.writeMessageEnd()
1708 
    self._oprot.trans.flush()
1709 
 
1710 
  def recv_getItemKeysToBeProcessed(self, ):
1711 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1712 
    if mtype == TMessageType.EXCEPTION:
1713 
      x = TApplicationException()
1714 
      x.read(self._iprot)
1715 
      self._iprot.readMessageEnd()
1716 
      raise x
1717 
    result = getItemKeysToBeProcessed_result()
1718 
    result.read(self._iprot)
1719 
    self._iprot.readMessageEnd()
1720 
    if result.success is not None:
1721 
      return result.success
1722 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemKeysToBeProcessed failed: unknown result");
1723 
 
1724 
  def markMissedInventoryUpdatesAsProcessed(self, itemKey, warehouseId):
1725 
    """
1726 
    Marks/Deletes missed inventory updates for a given key and warehouse.
1727 
    This generally happens when updates from PLB are applied on the currentinventorysnapshot for an item
1728 
 
1729 
    Parameters:
1730 
     - itemKey
1731 
     - warehouseId
1732 
    """
1733 
    self.send_markMissedInventoryUpdatesAsProcessed(itemKey, warehouseId)
1734 
    self.recv_markMissedInventoryUpdatesAsProcessed()
1735 
 
1736 
  def send_markMissedInventoryUpdatesAsProcessed(self, itemKey, warehouseId):
1737 
    self._oprot.writeMessageBegin('markMissedInventoryUpdatesAsProcessed', TMessageType.CALL, self._seqid)
1738 
    args = markMissedInventoryUpdatesAsProcessed_args()
1739 
    args.itemKey = itemKey
1740 
    args.warehouseId = warehouseId
1741 
    args.write(self._oprot)
1742 
    self._oprot.writeMessageEnd()
1743 
    self._oprot.trans.flush()
1744 
 
1745 
  def recv_markMissedInventoryUpdatesAsProcessed(self, ):
1746 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1747 
    if mtype == TMessageType.EXCEPTION:
1748 
      x = TApplicationException()
1749 
      x.read(self._iprot)
1750 
      self._iprot.readMessageEnd()
1751 
      raise x
1752 
    result = markMissedInventoryUpdatesAsProcessed_result()
1753 
    result.read(self._iprot)
1754 
    self._iprot.readMessageEnd()
1755 
    return
1756 
 
1757 
  def getIgnoredItemKeys(self, ):
1758 
    """
1759 
    Returns all the item key mappings that have been ignored until date. Value of map has the warehouse id
1760 
    and the timestamp from where alert was raised.
1761 
    """
1762 
    self.send_getIgnoredItemKeys()
1763 
    return self.recv_getIgnoredItemKeys()
1764 
 
1765 
  def send_getIgnoredItemKeys(self, ):
1766 
    self._oprot.writeMessageBegin('getIgnoredItemKeys', TMessageType.CALL, self._seqid)
1767 
    args = getIgnoredItemKeys_args()
1768 
    args.write(self._oprot)
1769 
    self._oprot.writeMessageEnd()
1770 
    self._oprot.trans.flush()
1771 
 
1772 
  def recv_getIgnoredItemKeys(self, ):
1773 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1774 
    if mtype == TMessageType.EXCEPTION:
1775 
      x = TApplicationException()
1776 
      x.read(self._iprot)
1777 
      self._iprot.readMessageEnd()
1778 
      raise x
1779 
    result = getIgnoredItemKeys_result()
1780 
    result.read(self._iprot)
1781 
    self._iprot.readMessageEnd()
1782 
    if result.success is not None:
1783 
      return result.success
1784 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getIgnoredItemKeys failed: unknown result");
1785 
 
1786 
  def addBadInventory(self, itemId, warehouseId, quantity):
1787 
    """
1788 
    Add the BAD type inventory to existing stock.
1789 
 
1790 
    Parameters:
1791 
     - itemId
1792 
     - warehouseId
1793 
     - quantity
1794 
    """
1795 
    self.send_addBadInventory(itemId, warehouseId, quantity)
1796 
    self.recv_addBadInventory()
1797 
 
1798 
  def send_addBadInventory(self, itemId, warehouseId, quantity):
1799 
    self._oprot.writeMessageBegin('addBadInventory', TMessageType.CALL, self._seqid)
1800 
    args = addBadInventory_args()
1801 
    args.itemId = itemId
1802 
    args.warehouseId = warehouseId
1803 
    args.quantity = quantity
1804 
    args.write(self._oprot)
1805 
    self._oprot.writeMessageEnd()
1806 
    self._oprot.trans.flush()
1807 
 
1808 
  def recv_addBadInventory(self, ):
1809 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1810 
    if mtype == TMessageType.EXCEPTION:
1811 
      x = TApplicationException()
1812 
      x.read(self._iprot)
1813 
      self._iprot.readMessageEnd()
1814 
      raise x
1815 
    result = addBadInventory_result()
1816 
    result.read(self._iprot)
1817 
    self._iprot.readMessageEnd()
1818 
    if result.cex is not None:
1819 
      raise result.cex
1820 
    return
1821 
 
1822 
  def getShippingLocations(self, ):
1823 
    """
1824 
    Returns all shipping locations
1825 
    """
1826 
    self.send_getShippingLocations()
1827 
    return self.recv_getShippingLocations()
1828 
 
1829 
  def send_getShippingLocations(self, ):
1830 
    self._oprot.writeMessageBegin('getShippingLocations', TMessageType.CALL, self._seqid)
1831 
    args = getShippingLocations_args()
1832 
    args.write(self._oprot)
1833 
    self._oprot.writeMessageEnd()
1834 
    self._oprot.trans.flush()
1835 
 
1836 
  def recv_getShippingLocations(self, ):
1837 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1838 
    if mtype == TMessageType.EXCEPTION:
1839 
      x = TApplicationException()
1840 
      x.read(self._iprot)
1841 
      self._iprot.readMessageEnd()
1842 
      raise x
1843 
    result = getShippingLocations_result()
1844 
    result.read(self._iprot)
1845 
    self._iprot.readMessageEnd()
1846 
    if result.success is not None:
1847 
      return result.success
1848 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getShippingLocations failed: unknown result");
1849 
 
1850 
  def getAllVendorItemMappings(self, ):
1851 
    """
1852 
    Fetches all the vendor item mappings present.
1853 
    """
1854 
    self.send_getAllVendorItemMappings()
1855 
    return self.recv_getAllVendorItemMappings()
1856 
 
1857 
  def send_getAllVendorItemMappings(self, ):
1858 
    self._oprot.writeMessageBegin('getAllVendorItemMappings', TMessageType.CALL, self._seqid)
1859 
    args = getAllVendorItemMappings_args()
1860 
    args.write(self._oprot)
1861 
    self._oprot.writeMessageEnd()
1862 
    self._oprot.trans.flush()
1863 
 
1864 
  def recv_getAllVendorItemMappings(self, ):
1865 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1866 
    if mtype == TMessageType.EXCEPTION:
1867 
      x = TApplicationException()
1868 
      x.read(self._iprot)
1869 
      self._iprot.readMessageEnd()
1870 
      raise x
1871 
    result = getAllVendorItemMappings_result()
1872 
    result.read(self._iprot)
1873 
    self._iprot.readMessageEnd()
1874 
    if result.success is not None:
1875 
      return result.success
1876 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVendorItemMappings failed: unknown result");
1877 
 
1878 
  def getInventorySnapshot(self, warehouseId):
1879 
    """
1880 
    Gets items' inventory for a warehouse
1881 
    If warehouse is passed as zero, items' inventory across all warehouses is sent
1882 
 
1883 
    Parameters:
1884 
     - warehouseId
1885 
    """
1886 
    self.send_getInventorySnapshot(warehouseId)
1887 
    return self.recv_getInventorySnapshot()
1888 
 
1889 
  def send_getInventorySnapshot(self, warehouseId):
1890 
    self._oprot.writeMessageBegin('getInventorySnapshot', TMessageType.CALL, self._seqid)
1891 
    args = getInventorySnapshot_args()
1892 
    args.warehouseId = warehouseId
1893 
    args.write(self._oprot)
1894 
    self._oprot.writeMessageEnd()
1895 
    self._oprot.trans.flush()
1896 
 
1897 
  def recv_getInventorySnapshot(self, ):
1898 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1899 
    if mtype == TMessageType.EXCEPTION:
1900 
      x = TApplicationException()
1901 
      x.read(self._iprot)
1902 
      self._iprot.readMessageEnd()
1903 
      raise x
1904 
    result = getInventorySnapshot_result()
1905 
    result.read(self._iprot)
1906 
    self._iprot.readMessageEnd()
1907 
    if result.success is not None:
1908 
      return result.success
1909 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventorySnapshot failed: unknown result");
1910 
 
1911 
  def clearItemAvailabilityCache(self, ):
1912 
    """
1913 
    Clear item availability cache.
1914 
    """
1915 
    self.send_clearItemAvailabilityCache()
1916 
    self.recv_clearItemAvailabilityCache()
1917 
 
1918 
  def send_clearItemAvailabilityCache(self, ):
1919 
    self._oprot.writeMessageBegin('clearItemAvailabilityCache', TMessageType.CALL, self._seqid)
1920 
    args = clearItemAvailabilityCache_args()
1921 
    args.write(self._oprot)
1922 
    self._oprot.writeMessageEnd()
1923 
    self._oprot.trans.flush()
1924 
 
1925 
  def recv_clearItemAvailabilityCache(self, ):
1926 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1927 
    if mtype == TMessageType.EXCEPTION:
1928 
      x = TApplicationException()
1929 
      x.read(self._iprot)
1930 
      self._iprot.readMessageEnd()
1931 
      raise x
1932 
    result = clearItemAvailabilityCache_result()
1933 
    result.read(self._iprot)
1934 
    self._iprot.readMessageEnd()
1935 
    return
1936 
 
1937 
  def updateVendorString(self, warehouseId, vendorString):
1938 
    """
1939 
    Parameters:
1940 
     - warehouseId
1941 
     - vendorString
1942 
    """
1943 
    self.send_updateVendorString(warehouseId, vendorString)
1944 
    self.recv_updateVendorString()
1945 
 
1946 
  def send_updateVendorString(self, warehouseId, vendorString):
1947 
    self._oprot.writeMessageBegin('updateVendorString', TMessageType.CALL, self._seqid)
1948 
    args = updateVendorString_args()
1949 
    args.warehouseId = warehouseId
1950 
    args.vendorString = vendorString
1951 
    args.write(self._oprot)
1952 
    self._oprot.writeMessageEnd()
1953 
    self._oprot.trans.flush()
1954 
 
1955 
  def recv_updateVendorString(self, ):
1956 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1957 
    if mtype == TMessageType.EXCEPTION:
1958 
      x = TApplicationException()
1959 
      x.read(self._iprot)
1960 
      self._iprot.readMessageEnd()
1961 
      raise x
1962 
    result = updateVendorString_result()
1963 
    result.read(self._iprot)
1964 
    self._iprot.readMessageEnd()
1965 
    return
1966 
 
6096 amit.gupta 1967 
  def clearItemAvailabilityCacheForItem(self, item_id):
1968 
    """
1969 
    Parameters:
1970 
     - item_id
1971 
    """
1972 
    self.send_clearItemAvailabilityCacheForItem(item_id)
1973 
    self.recv_clearItemAvailabilityCacheForItem()
5944 mandeep.dh 1974 
 
6096 amit.gupta 1975 
  def send_clearItemAvailabilityCacheForItem(self, item_id):
1976 
    self._oprot.writeMessageBegin('clearItemAvailabilityCacheForItem', TMessageType.CALL, self._seqid)
1977 
    args = clearItemAvailabilityCacheForItem_args()
1978 
    args.item_id = item_id
1979 
    args.write(self._oprot)
1980 
    self._oprot.writeMessageEnd()
1981 
    self._oprot.trans.flush()
1982 
 
1983 
  def recv_clearItemAvailabilityCacheForItem(self, ):
1984 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1985 
    if mtype == TMessageType.EXCEPTION:
1986 
      x = TApplicationException()
1987 
      x.read(self._iprot)
1988 
      self._iprot.readMessageEnd()
1989 
      raise x
1990 
    result = clearItemAvailabilityCacheForItem_result()
1991 
    result.read(self._iprot)
1992 
    self._iprot.readMessageEnd()
1993 
    return
1994 
 
7718 amar.kumar 1995 
  def getOurWarehouseIdForVendor(self, vendorId, billingWarehouseId):
6467 amar.kumar 1996 
    """
1997 
    Parameters:
1998 
     - vendorId
7718 amar.kumar 1999 
     - billingWarehouseId
6467 amar.kumar 2000 
    """
7718 amar.kumar 2001 
    self.send_getOurWarehouseIdForVendor(vendorId, billingWarehouseId)
6467 amar.kumar 2002 
    return self.recv_getOurWarehouseIdForVendor()
6096 amit.gupta 2003 
 
7718 amar.kumar 2004 
  def send_getOurWarehouseIdForVendor(self, vendorId, billingWarehouseId):
6467 amar.kumar 2005 
    self._oprot.writeMessageBegin('getOurWarehouseIdForVendor', TMessageType.CALL, self._seqid)
2006 
    args = getOurWarehouseIdForVendor_args()
2007 
    args.vendorId = vendorId
7718 amar.kumar 2008 
    args.billingWarehouseId = billingWarehouseId
6467 amar.kumar 2009 
    args.write(self._oprot)
2010 
    self._oprot.writeMessageEnd()
2011 
    self._oprot.trans.flush()
2012 
 
2013 
  def recv_getOurWarehouseIdForVendor(self, ):
2014 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2015 
    if mtype == TMessageType.EXCEPTION:
2016 
      x = TApplicationException()
2017 
      x.read(self._iprot)
2018 
      self._iprot.readMessageEnd()
2019 
      raise x
2020 
    result = getOurWarehouseIdForVendor_result()
2021 
    result.read(self._iprot)
2022 
    self._iprot.readMessageEnd()
2023 
    if result.success is not None:
2024 
      return result.success
2025 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOurWarehouseIdForVendor failed: unknown result");
2026 
 
6484 amar.kumar 2027 
  def getItemAvailabilitiesAtOurWarehouses(self, item_ids):
2028 
    """
2029 
    Parameters:
2030 
     - item_ids
2031 
    """
2032 
    self.send_getItemAvailabilitiesAtOurWarehouses(item_ids)
2033 
    return self.recv_getItemAvailabilitiesAtOurWarehouses()
6467 amar.kumar 2034 
 
6484 amar.kumar 2035 
  def send_getItemAvailabilitiesAtOurWarehouses(self, item_ids):
2036 
    self._oprot.writeMessageBegin('getItemAvailabilitiesAtOurWarehouses', TMessageType.CALL, self._seqid)
2037 
    args = getItemAvailabilitiesAtOurWarehouses_args()
2038 
    args.item_ids = item_ids
2039 
    args.write(self._oprot)
2040 
    self._oprot.writeMessageEnd()
2041 
    self._oprot.trans.flush()
2042 
 
2043 
  def recv_getItemAvailabilitiesAtOurWarehouses(self, ):
2044 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2045 
    if mtype == TMessageType.EXCEPTION:
2046 
      x = TApplicationException()
2047 
      x.read(self._iprot)
2048 
      self._iprot.readMessageEnd()
2049 
      raise x
2050 
    result = getItemAvailabilitiesAtOurWarehouses_result()
2051 
    result.read(self._iprot)
2052 
    self._iprot.readMessageEnd()
2053 
    if result.success is not None:
2054 
      return result.success
2055 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemAvailabilitiesAtOurWarehouses failed: unknown result");
2056 
 
6531 vikram.rag 2057 
  def getMonitoredWarehouseForVendors(self, vendorIds):
2058 
    """
2059 
    Parameters:
2060 
     - vendorIds
2061 
    """
2062 
    self.send_getMonitoredWarehouseForVendors(vendorIds)
2063 
    return self.recv_getMonitoredWarehouseForVendors()
6484 amar.kumar 2064 
 
6531 vikram.rag 2065 
  def send_getMonitoredWarehouseForVendors(self, vendorIds):
2066 
    self._oprot.writeMessageBegin('getMonitoredWarehouseForVendors', TMessageType.CALL, self._seqid)
2067 
    args = getMonitoredWarehouseForVendors_args()
2068 
    args.vendorIds = vendorIds
2069 
    args.write(self._oprot)
2070 
    self._oprot.writeMessageEnd()
2071 
    self._oprot.trans.flush()
2072 
 
2073 
  def recv_getMonitoredWarehouseForVendors(self, ):
2074 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2075 
    if mtype == TMessageType.EXCEPTION:
2076 
      x = TApplicationException()
2077 
      x.read(self._iprot)
2078 
      self._iprot.readMessageEnd()
2079 
      raise x
2080 
    result = getMonitoredWarehouseForVendors_result()
2081 
    result.read(self._iprot)
2082 
    self._iprot.readMessageEnd()
2083 
    if result.success is not None:
2084 
      return result.success
2085 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMonitoredWarehouseForVendors failed: unknown result");
2086 
 
2087 
  def getIgnoredWarehouseidsAndItemids(self, ):
2088 
    self.send_getIgnoredWarehouseidsAndItemids()
2089 
    return self.recv_getIgnoredWarehouseidsAndItemids()
2090 
 
2091 
  def send_getIgnoredWarehouseidsAndItemids(self, ):
2092 
    self._oprot.writeMessageBegin('getIgnoredWarehouseidsAndItemids', TMessageType.CALL, self._seqid)
2093 
    args = getIgnoredWarehouseidsAndItemids_args()
2094 
    args.write(self._oprot)
2095 
    self._oprot.writeMessageEnd()
2096 
    self._oprot.trans.flush()
2097 
 
2098 
  def recv_getIgnoredWarehouseidsAndItemids(self, ):
2099 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2100 
    if mtype == TMessageType.EXCEPTION:
2101 
      x = TApplicationException()
2102 
      x.read(self._iprot)
2103 
      self._iprot.readMessageEnd()
2104 
      raise x
2105 
    result = getIgnoredWarehouseidsAndItemids_result()
2106 
    result.read(self._iprot)
2107 
    self._iprot.readMessageEnd()
2108 
    if result.success is not None:
2109 
      return result.success
2110 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getIgnoredWarehouseidsAndItemids failed: unknown result");
2111 
 
2112 
  def insertItemtoIgnoreInventoryUpdatelist(self, item_id, warehouse_id):
2113 
    """
2114 
    Parameters:
2115 
     - item_id
2116 
     - warehouse_id
2117 
    """
2118 
    self.send_insertItemtoIgnoreInventoryUpdatelist(item_id, warehouse_id)
2119 
    return self.recv_insertItemtoIgnoreInventoryUpdatelist()
2120 
 
2121 
  def send_insertItemtoIgnoreInventoryUpdatelist(self, item_id, warehouse_id):
2122 
    self._oprot.writeMessageBegin('insertItemtoIgnoreInventoryUpdatelist', TMessageType.CALL, self._seqid)
2123 
    args = insertItemtoIgnoreInventoryUpdatelist_args()
2124 
    args.item_id = item_id
2125 
    args.warehouse_id = warehouse_id
2126 
    args.write(self._oprot)
2127 
    self._oprot.writeMessageEnd()
2128 
    self._oprot.trans.flush()
2129 
 
2130 
  def recv_insertItemtoIgnoreInventoryUpdatelist(self, ):
2131 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2132 
    if mtype == TMessageType.EXCEPTION:
2133 
      x = TApplicationException()
2134 
      x.read(self._iprot)
2135 
      self._iprot.readMessageEnd()
2136 
      raise x
2137 
    result = insertItemtoIgnoreInventoryUpdatelist_result()
2138 
    result.read(self._iprot)
2139 
    self._iprot.readMessageEnd()
2140 
    if result.success is not None:
2141 
      return result.success
2142 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "insertItemtoIgnoreInventoryUpdatelist failed: unknown result");
2143 
 
2144 
  def deleteItemFromIgnoredInventoryUpdateList(self, item_id, warehouse_id):
2145 
    """
2146 
    Parameters:
2147 
     - item_id
2148 
     - warehouse_id
2149 
    """
2150 
    self.send_deleteItemFromIgnoredInventoryUpdateList(item_id, warehouse_id)
2151 
    return self.recv_deleteItemFromIgnoredInventoryUpdateList()
2152 
 
2153 
  def send_deleteItemFromIgnoredInventoryUpdateList(self, item_id, warehouse_id):
2154 
    self._oprot.writeMessageBegin('deleteItemFromIgnoredInventoryUpdateList', TMessageType.CALL, self._seqid)
2155 
    args = deleteItemFromIgnoredInventoryUpdateList_args()
2156 
    args.item_id = item_id
2157 
    args.warehouse_id = warehouse_id
2158 
    args.write(self._oprot)
2159 
    self._oprot.writeMessageEnd()
2160 
    self._oprot.trans.flush()
2161 
 
2162 
  def recv_deleteItemFromIgnoredInventoryUpdateList(self, ):
2163 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2164 
    if mtype == TMessageType.EXCEPTION:
2165 
      x = TApplicationException()
2166 
      x.read(self._iprot)
2167 
      self._iprot.readMessageEnd()
2168 
      raise x
2169 
    result = deleteItemFromIgnoredInventoryUpdateList_result()
2170 
    result.read(self._iprot)
2171 
    self._iprot.readMessageEnd()
2172 
    if result.success is not None:
2173 
      return result.success
2174 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteItemFromIgnoredInventoryUpdateList failed: unknown result");
2175 
 
2176 
  def getAllIgnoredInventoryupdateItemsCount(self, ):
2177 
    self.send_getAllIgnoredInventoryupdateItemsCount()
2178 
    return self.recv_getAllIgnoredInventoryupdateItemsCount()
2179 
 
2180 
  def send_getAllIgnoredInventoryupdateItemsCount(self, ):
2181 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryupdateItemsCount', TMessageType.CALL, self._seqid)
2182 
    args = getAllIgnoredInventoryupdateItemsCount_args()
2183 
    args.write(self._oprot)
2184 
    self._oprot.writeMessageEnd()
2185 
    self._oprot.trans.flush()
2186 
 
2187 
  def recv_getAllIgnoredInventoryupdateItemsCount(self, ):
2188 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2189 
    if mtype == TMessageType.EXCEPTION:
2190 
      x = TApplicationException()
2191 
      x.read(self._iprot)
2192 
      self._iprot.readMessageEnd()
2193 
      raise x
2194 
    result = getAllIgnoredInventoryupdateItemsCount_result()
2195 
    result.read(self._iprot)
2196 
    self._iprot.readMessageEnd()
2197 
    if result.success is not None:
2198 
      return result.success
2199 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryupdateItemsCount failed: unknown result");
2200 
 
2201 
  def getIgnoredInventoryUpdateItemids(self, offset, limit):
2202 
    """
2203 
    Parameters:
2204 
     - offset
2205 
     - limit
2206 
    """
2207 
    self.send_getIgnoredInventoryUpdateItemids(offset, limit)
2208 
    return self.recv_getIgnoredInventoryUpdateItemids()
2209 
 
2210 
  def send_getIgnoredInventoryUpdateItemids(self, offset, limit):
2211 
    self._oprot.writeMessageBegin('getIgnoredInventoryUpdateItemids', TMessageType.CALL, self._seqid)
2212 
    args = getIgnoredInventoryUpdateItemids_args()
2213 
    args.offset = offset
2214 
    args.limit = limit
2215 
    args.write(self._oprot)
2216 
    self._oprot.writeMessageEnd()
2217 
    self._oprot.trans.flush()
2218 
 
2219 
  def recv_getIgnoredInventoryUpdateItemids(self, ):
2220 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2221 
    if mtype == TMessageType.EXCEPTION:
2222 
      x = TApplicationException()
2223 
      x.read(self._iprot)
2224 
      self._iprot.readMessageEnd()
2225 
      raise x
2226 
    result = getIgnoredInventoryUpdateItemids_result()
2227 
    result.read(self._iprot)
2228 
    self._iprot.readMessageEnd()
2229 
    if result.success is not None:
2230 
      return result.success
2231 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getIgnoredInventoryUpdateItemids failed: unknown result");
2232 
 
6821 amar.kumar 2233 
  def updateItemStockPurchaseParams(self, item_id, numOfDaysStock, minStockLevel):
2234 
    """
2235 
    Parameters:
2236 
     - item_id
2237 
     - numOfDaysStock
2238 
     - minStockLevel
2239 
    """
2240 
    self.send_updateItemStockPurchaseParams(item_id, numOfDaysStock, minStockLevel)
2241 
    self.recv_updateItemStockPurchaseParams()
6531 vikram.rag 2242 
 
6821 amar.kumar 2243 
  def send_updateItemStockPurchaseParams(self, item_id, numOfDaysStock, minStockLevel):
2244 
    self._oprot.writeMessageBegin('updateItemStockPurchaseParams', TMessageType.CALL, self._seqid)
2245 
    args = updateItemStockPurchaseParams_args()
2246 
    args.item_id = item_id
2247 
    args.numOfDaysStock = numOfDaysStock
2248 
    args.minStockLevel = minStockLevel
2249 
    args.write(self._oprot)
2250 
    self._oprot.writeMessageEnd()
2251 
    self._oprot.trans.flush()
2252 
 
2253 
  def recv_updateItemStockPurchaseParams(self, ):
2254 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2255 
    if mtype == TMessageType.EXCEPTION:
2256 
      x = TApplicationException()
2257 
      x.read(self._iprot)
2258 
      self._iprot.readMessageEnd()
2259 
      raise x
2260 
    result = updateItemStockPurchaseParams_result()
2261 
    result.read(self._iprot)
2262 
    self._iprot.readMessageEnd()
2263 
    return
2264 
 
2265 
  def getItemStockPurchaseParams(self, itemId):
2266 
    """
2267 
    Parameters:
2268 
     - itemId
2269 
    """
2270 
    self.send_getItemStockPurchaseParams(itemId)
2271 
    return self.recv_getItemStockPurchaseParams()
2272 
 
2273 
  def send_getItemStockPurchaseParams(self, itemId):
2274 
    self._oprot.writeMessageBegin('getItemStockPurchaseParams', TMessageType.CALL, self._seqid)
2275 
    args = getItemStockPurchaseParams_args()
2276 
    args.itemId = itemId
2277 
    args.write(self._oprot)
2278 
    self._oprot.writeMessageEnd()
2279 
    self._oprot.trans.flush()
2280 
 
2281 
  def recv_getItemStockPurchaseParams(self, ):
2282 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2283 
    if mtype == TMessageType.EXCEPTION:
2284 
      x = TApplicationException()
2285 
      x.read(self._iprot)
2286 
      self._iprot.readMessageEnd()
2287 
      raise x
2288 
    result = getItemStockPurchaseParams_result()
2289 
    result.read(self._iprot)
2290 
    self._iprot.readMessageEnd()
2291 
    if result.success is not None:
2292 
      return result.success
2293 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStockPurchaseParams failed: unknown result");
2294 
 
2295 
  def addOosStatusForItem(self, oosStatusMap, date):
2296 
    """
2297 
    Parameters:
2298 
     - oosStatusMap
2299 
     - date
2300 
    """
2301 
    self.send_addOosStatusForItem(oosStatusMap, date)
2302 
    self.recv_addOosStatusForItem()
2303 
 
2304 
  def send_addOosStatusForItem(self, oosStatusMap, date):
2305 
    self._oprot.writeMessageBegin('addOosStatusForItem', TMessageType.CALL, self._seqid)
2306 
    args = addOosStatusForItem_args()
2307 
    args.oosStatusMap = oosStatusMap
2308 
    args.date = date
2309 
    args.write(self._oprot)
2310 
    self._oprot.writeMessageEnd()
2311 
    self._oprot.trans.flush()
2312 
 
2313 
  def recv_addOosStatusForItem(self, ):
2314 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2315 
    if mtype == TMessageType.EXCEPTION:
2316 
      x = TApplicationException()
2317 
      x.read(self._iprot)
2318 
      self._iprot.readMessageEnd()
2319 
      raise x
2320 
    result = addOosStatusForItem_result()
2321 
    result.read(self._iprot)
2322 
    self._iprot.readMessageEnd()
2323 
    return
2324 
 
9762 amar.kumar 2325 
  def getOosStatusesForXDaysForItem(self, itemId, sourceId, days):
6832 amar.kumar 2326 
    """
2327 
    Parameters:
2328 
     - itemId
9762 amar.kumar 2329 
     - sourceId
6832 amar.kumar 2330 
     - days
2331 
    """
9762 amar.kumar 2332 
    self.send_getOosStatusesForXDaysForItem(itemId, sourceId, days)
6832 amar.kumar 2333 
    return self.recv_getOosStatusesForXDaysForItem()
6821 amar.kumar 2334 
 
9762 amar.kumar 2335 
  def send_getOosStatusesForXDaysForItem(self, itemId, sourceId, days):
6832 amar.kumar 2336 
    self._oprot.writeMessageBegin('getOosStatusesForXDaysForItem', TMessageType.CALL, self._seqid)
2337 
    args = getOosStatusesForXDaysForItem_args()
2338 
    args.itemId = itemId
9762 amar.kumar 2339 
    args.sourceId = sourceId
6832 amar.kumar 2340 
    args.days = days
2341 
    args.write(self._oprot)
2342 
    self._oprot.writeMessageEnd()
2343 
    self._oprot.trans.flush()
2344 
 
2345 
  def recv_getOosStatusesForXDaysForItem(self, ):
2346 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2347 
    if mtype == TMessageType.EXCEPTION:
2348 
      x = TApplicationException()
2349 
      x.read(self._iprot)
2350 
      self._iprot.readMessageEnd()
2351 
      raise x
2352 
    result = getOosStatusesForXDaysForItem_result()
2353 
    result.read(self._iprot)
2354 
    self._iprot.readMessageEnd()
2355 
    if result.success is not None:
2356 
      return result.success
2357 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOosStatusesForXDaysForItem failed: unknown result");
2358 
 
10126 amar.kumar 2359 
  def getOosStatusesForXDays(self, sourceId, days):
2360 
    """
2361 
    Parameters:
2362 
     - sourceId
2363 
     - days
2364 
    """
2365 
    self.send_getOosStatusesForXDays(sourceId, days)
2366 
    return self.recv_getOosStatusesForXDays()
2367 
 
2368 
  def send_getOosStatusesForXDays(self, sourceId, days):
2369 
    self._oprot.writeMessageBegin('getOosStatusesForXDays', TMessageType.CALL, self._seqid)
2370 
    args = getOosStatusesForXDays_args()
2371 
    args.sourceId = sourceId
2372 
    args.days = days
2373 
    args.write(self._oprot)
2374 
    self._oprot.writeMessageEnd()
2375 
    self._oprot.trans.flush()
2376 
 
2377 
  def recv_getOosStatusesForXDays(self, ):
2378 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2379 
    if mtype == TMessageType.EXCEPTION:
2380 
      x = TApplicationException()
2381 
      x.read(self._iprot)
2382 
      self._iprot.readMessageEnd()
2383 
      raise x
2384 
    result = getOosStatusesForXDays_result()
2385 
    result.read(self._iprot)
2386 
    self._iprot.readMessageEnd()
2387 
    if result.success is not None:
2388 
      return result.success
2389 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOosStatusesForXDays failed: unknown result");
2390 
 
2391 
  def getAllVendorItemPricing(self, itemId, vendorId):
2392 
    """
2393 
    Parameters:
2394 
     - itemId
2395 
     - vendorId
2396 
    """
2397 
    self.send_getAllVendorItemPricing(itemId, vendorId)
2398 
    return self.recv_getAllVendorItemPricing()
2399 
 
2400 
  def send_getAllVendorItemPricing(self, itemId, vendorId):
2401 
    self._oprot.writeMessageBegin('getAllVendorItemPricing', TMessageType.CALL, self._seqid)
2402 
    args = getAllVendorItemPricing_args()
2403 
    args.itemId = itemId
2404 
    args.vendorId = vendorId
2405 
    args.write(self._oprot)
2406 
    self._oprot.writeMessageEnd()
2407 
    self._oprot.trans.flush()
2408 
 
2409 
  def recv_getAllVendorItemPricing(self, ):
2410 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2411 
    if mtype == TMessageType.EXCEPTION:
2412 
      x = TApplicationException()
2413 
      x.read(self._iprot)
2414 
      self._iprot.readMessageEnd()
2415 
      raise x
2416 
    result = getAllVendorItemPricing_result()
2417 
    result.read(self._iprot)
2418 
    self._iprot.readMessageEnd()
2419 
    if result.success is not None:
2420 
      return result.success
2421 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVendorItemPricing failed: unknown result");
2422 
 
6857 amar.kumar 2423 
  def getNonZeroItemStockPurchaseParams(self, ):
2424 
    self.send_getNonZeroItemStockPurchaseParams()
2425 
    return self.recv_getNonZeroItemStockPurchaseParams()
6832 amar.kumar 2426 
 
6857 amar.kumar 2427 
  def send_getNonZeroItemStockPurchaseParams(self, ):
2428 
    self._oprot.writeMessageBegin('getNonZeroItemStockPurchaseParams', TMessageType.CALL, self._seqid)
2429 
    args = getNonZeroItemStockPurchaseParams_args()
2430 
    args.write(self._oprot)
2431 
    self._oprot.writeMessageEnd()
2432 
    self._oprot.trans.flush()
2433 
 
2434 
  def recv_getNonZeroItemStockPurchaseParams(self, ):
2435 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2436 
    if mtype == TMessageType.EXCEPTION:
2437 
      x = TApplicationException()
2438 
      x.read(self._iprot)
2439 
      self._iprot.readMessageEnd()
2440 
      raise x
2441 
    result = getNonZeroItemStockPurchaseParams_result()
2442 
    result.read(self._iprot)
2443 
    self._iprot.readMessageEnd()
2444 
    if result.success is not None:
2445 
      return result.success
2446 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonZeroItemStockPurchaseParams failed: unknown result");
2447 
 
7149 amar.kumar 2448 
  def getBillableInventoryAndPendingOrders(self, ):
2449 
    """
2450 
    Returns a list of inventory stock for items for which there are pending orders or have billable inventory.
2451 
    """
2452 
    self.send_getBillableInventoryAndPendingOrders()
2453 
    return self.recv_getBillableInventoryAndPendingOrders()
6857 amar.kumar 2454 
 
7149 amar.kumar 2455 
  def send_getBillableInventoryAndPendingOrders(self, ):
2456 
    self._oprot.writeMessageBegin('getBillableInventoryAndPendingOrders', TMessageType.CALL, self._seqid)
2457 
    args = getBillableInventoryAndPendingOrders_args()
2458 
    args.write(self._oprot)
2459 
    self._oprot.writeMessageEnd()
2460 
    self._oprot.trans.flush()
2461 
 
2462 
  def recv_getBillableInventoryAndPendingOrders(self, ):
2463 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2464 
    if mtype == TMessageType.EXCEPTION:
2465 
      x = TApplicationException()
2466 
      x.read(self._iprot)
2467 
      self._iprot.readMessageEnd()
2468 
      raise x
2469 
    result = getBillableInventoryAndPendingOrders_result()
2470 
    result.read(self._iprot)
2471 
    self._iprot.readMessageEnd()
2472 
    if result.success is not None:
2473 
      return result.success
2474 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBillableInventoryAndPendingOrders failed: unknown result");
2475 
 
7281 kshitij.so 2476 
  def getWarehouseName(self, warehouse_id):
2477 
    """
2478 
    Parameters:
2479 
     - warehouse_id
2480 
    """
2481 
    self.send_getWarehouseName(warehouse_id)
2482 
    return self.recv_getWarehouseName()
7149 amar.kumar 2483 
 
7281 kshitij.so 2484 
  def send_getWarehouseName(self, warehouse_id):
2485 
    self._oprot.writeMessageBegin('getWarehouseName', TMessageType.CALL, self._seqid)
2486 
    args = getWarehouseName_args()
2487 
    args.warehouse_id = warehouse_id
2488 
    args.write(self._oprot)
2489 
    self._oprot.writeMessageEnd()
2490 
    self._oprot.trans.flush()
2491 
 
2492 
  def recv_getWarehouseName(self, ):
2493 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2494 
    if mtype == TMessageType.EXCEPTION:
2495 
      x = TApplicationException()
2496 
      x.read(self._iprot)
2497 
      self._iprot.readMessageEnd()
2498 
      raise x
2499 
    result = getWarehouseName_result()
2500 
    result.read(self._iprot)
2501 
    self._iprot.readMessageEnd()
2502 
    if result.success is not None:
2503 
      return result.success
2504 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getWarehouseName failed: unknown result");
2505 
 
2506 
  def getAmazonInventoryForItem(self, item_id):
2507 
    """
2508 
    Parameters:
2509 
     - item_id
2510 
    """
2511 
    self.send_getAmazonInventoryForItem(item_id)
2512 
    return self.recv_getAmazonInventoryForItem()
2513 
 
2514 
  def send_getAmazonInventoryForItem(self, item_id):
2515 
    self._oprot.writeMessageBegin('getAmazonInventoryForItem', TMessageType.CALL, self._seqid)
2516 
    args = getAmazonInventoryForItem_args()
2517 
    args.item_id = item_id
2518 
    args.write(self._oprot)
2519 
    self._oprot.writeMessageEnd()
2520 
    self._oprot.trans.flush()
2521 
 
2522 
  def recv_getAmazonInventoryForItem(self, ):
2523 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2524 
    if mtype == TMessageType.EXCEPTION:
2525 
      x = TApplicationException()
2526 
      x.read(self._iprot)
2527 
      self._iprot.readMessageEnd()
2528 
      raise x
2529 
    result = getAmazonInventoryForItem_result()
2530 
    result.read(self._iprot)
2531 
    self._iprot.readMessageEnd()
2532 
    if result.success is not None:
2533 
      return result.success
2534 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonInventoryForItem failed: unknown result");
2535 
 
2536 
  def getAllAmazonInventory(self, ):
2537 
    self.send_getAllAmazonInventory()
2538 
    return self.recv_getAllAmazonInventory()
2539 
 
2540 
  def send_getAllAmazonInventory(self, ):
2541 
    self._oprot.writeMessageBegin('getAllAmazonInventory', TMessageType.CALL, self._seqid)
2542 
    args = getAllAmazonInventory_args()
2543 
    args.write(self._oprot)
2544 
    self._oprot.writeMessageEnd()
2545 
    self._oprot.trans.flush()
2546 
 
2547 
  def recv_getAllAmazonInventory(self, ):
2548 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2549 
    if mtype == TMessageType.EXCEPTION:
2550 
      x = TApplicationException()
2551 
      x.read(self._iprot)
2552 
      self._iprot.readMessageEnd()
2553 
      raise x
2554 
    result = getAllAmazonInventory_result()
2555 
    result.read(self._iprot)
2556 
    self._iprot.readMessageEnd()
2557 
    if result.success is not None:
2558 
      return result.success
2559 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonInventory failed: unknown result");
2560 
 
10450 vikram.rag 2561 
  def addOrUpdateAmazonInventoryForItem(self, amazonInventorySnapshot, time):
7281 kshitij.so 2562 
    """
2563 
    Parameters:
2564 
     - amazonInventorySnapshot
10450 vikram.rag 2565 
     - time
7281 kshitij.so 2566 
    """
10450 vikram.rag 2567 
    self.send_addOrUpdateAmazonInventoryForItem(amazonInventorySnapshot, time)
7281 kshitij.so 2568 
    self.recv_addOrUpdateAmazonInventoryForItem()
2569 
 
10450 vikram.rag 2570 
  def send_addOrUpdateAmazonInventoryForItem(self, amazonInventorySnapshot, time):
7281 kshitij.so 2571 
    self._oprot.writeMessageBegin('addOrUpdateAmazonInventoryForItem', TMessageType.CALL, self._seqid)
2572 
    args = addOrUpdateAmazonInventoryForItem_args()
2573 
    args.amazonInventorySnapshot = amazonInventorySnapshot
10450 vikram.rag 2574 
    args.time = time
7281 kshitij.so 2575 
    args.write(self._oprot)
2576 
    self._oprot.writeMessageEnd()
2577 
    self._oprot.trans.flush()
2578 
 
2579 
  def recv_addOrUpdateAmazonInventoryForItem(self, ):
2580 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2581 
    if mtype == TMessageType.EXCEPTION:
2582 
      x = TApplicationException()
2583 
      x.read(self._iprot)
2584 
      self._iprot.readMessageEnd()
2585 
      raise x
2586 
    result = addOrUpdateAmazonInventoryForItem_result()
2587 
    result.read(self._iprot)
2588 
    self._iprot.readMessageEnd()
2589 
    return
2590 
 
7972 amar.kumar 2591 
  def getLastNdaySaleForItem(self, itemId, numberOfDays):
2592 
    """
2593 
    Parameters:
2594 
     - itemId
2595 
     - numberOfDays
2596 
    """
2597 
    self.send_getLastNdaySaleForItem(itemId, numberOfDays)
2598 
    return self.recv_getLastNdaySaleForItem()
7281 kshitij.so 2599 
 
7972 amar.kumar 2600 
  def send_getLastNdaySaleForItem(self, itemId, numberOfDays):
2601 
    self._oprot.writeMessageBegin('getLastNdaySaleForItem', TMessageType.CALL, self._seqid)
2602 
    args = getLastNdaySaleForItem_args()
2603 
    args.itemId = itemId
2604 
    args.numberOfDays = numberOfDays
2605 
    args.write(self._oprot)
2606 
    self._oprot.writeMessageEnd()
2607 
    self._oprot.trans.flush()
2608 
 
2609 
  def recv_getLastNdaySaleForItem(self, ):
2610 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2611 
    if mtype == TMessageType.EXCEPTION:
2612 
      x = TApplicationException()
2613 
      x.read(self._iprot)
2614 
      self._iprot.readMessageEnd()
2615 
      raise x
2616 
    result = getLastNdaySaleForItem_result()
2617 
    result.read(self._iprot)
2618 
    self._iprot.readMessageEnd()
2619 
    if result.success is not None:
2620 
      return result.success
2621 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLastNdaySaleForItem failed: unknown result");
2622 
 
8282 kshitij.so 2623 
  def addOrUpdateAmazonFbaInventory(self, amazonfbainventorysnapshot):
2624 
    """
2625 
    Parameters:
2626 
     - amazonfbainventorysnapshot
2627 
    """
2628 
    self.send_addOrUpdateAmazonFbaInventory(amazonfbainventorysnapshot)
2629 
    self.recv_addOrUpdateAmazonFbaInventory()
2630 
 
2631 
  def send_addOrUpdateAmazonFbaInventory(self, amazonfbainventorysnapshot):
2632 
    self._oprot.writeMessageBegin('addOrUpdateAmazonFbaInventory', TMessageType.CALL, self._seqid)
2633 
    args = addOrUpdateAmazonFbaInventory_args()
2634 
    args.amazonfbainventorysnapshot = amazonfbainventorysnapshot
2635 
    args.write(self._oprot)
2636 
    self._oprot.writeMessageEnd()
2637 
    self._oprot.trans.flush()
2638 
 
2639 
  def recv_addOrUpdateAmazonFbaInventory(self, ):
2640 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2641 
    if mtype == TMessageType.EXCEPTION:
2642 
      x = TApplicationException()
2643 
      x.read(self._iprot)
2644 
      self._iprot.readMessageEnd()
2645 
      raise x
2646 
    result = addOrUpdateAmazonFbaInventory_result()
2647 
    result.read(self._iprot)
2648 
    self._iprot.readMessageEnd()
2649 
    return
2650 
 
8182 amar.kumar 2651 
  def addUpdateHoldInventory(self, itemId, warehouseId, holdQuantity, source):
2652 
    """
2653 
    Parameters:
2654 
     - itemId
2655 
     - warehouseId
2656 
     - holdQuantity
2657 
     - source
2658 
    """
2659 
    self.send_addUpdateHoldInventory(itemId, warehouseId, holdQuantity, source)
2660 
    self.recv_addUpdateHoldInventory()
7972 amar.kumar 2661 
 
8182 amar.kumar 2662 
  def send_addUpdateHoldInventory(self, itemId, warehouseId, holdQuantity, source):
2663 
    self._oprot.writeMessageBegin('addUpdateHoldInventory', TMessageType.CALL, self._seqid)
2664 
    args = addUpdateHoldInventory_args()
2665 
    args.itemId = itemId
2666 
    args.warehouseId = warehouseId
2667 
    args.holdQuantity = holdQuantity
2668 
    args.source = source
2669 
    args.write(self._oprot)
2670 
    self._oprot.writeMessageEnd()
2671 
    self._oprot.trans.flush()
2672 
 
2673 
  def recv_addUpdateHoldInventory(self, ):
2674 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2675 
    if mtype == TMessageType.EXCEPTION:
2676 
      x = TApplicationException()
2677 
      x.read(self._iprot)
2678 
      self._iprot.readMessageEnd()
2679 
      raise x
2680 
    result = addUpdateHoldInventory_result()
2681 
    result.read(self._iprot)
2682 
    self._iprot.readMessageEnd()
9762 amar.kumar 2683 
    if result.cex is not None:
2684 
      raise result.cex
8182 amar.kumar 2685 
    return
2686 
 
8282 kshitij.so 2687 
  def getAmazonFbaItemInventory(self, itemId):
2688 
    """
2689 
    Parameters:
2690 
     - itemId
2691 
    """
2692 
    self.send_getAmazonFbaItemInventory(itemId)
2693 
    return self.recv_getAmazonFbaItemInventory()
8182 amar.kumar 2694 
 
8282 kshitij.so 2695 
  def send_getAmazonFbaItemInventory(self, itemId):
2696 
    self._oprot.writeMessageBegin('getAmazonFbaItemInventory', TMessageType.CALL, self._seqid)
2697 
    args = getAmazonFbaItemInventory_args()
2698 
    args.itemId = itemId
2699 
    args.write(self._oprot)
2700 
    self._oprot.writeMessageEnd()
2701 
    self._oprot.trans.flush()
2702 
 
2703 
  def recv_getAmazonFbaItemInventory(self, ):
2704 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2705 
    if mtype == TMessageType.EXCEPTION:
2706 
      x = TApplicationException()
2707 
      x.read(self._iprot)
2708 
      self._iprot.readMessageEnd()
2709 
      raise x
2710 
    result = getAmazonFbaItemInventory_result()
2711 
    result.read(self._iprot)
2712 
    self._iprot.readMessageEnd()
2713 
    if result.success is not None:
2714 
      return result.success
2715 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonFbaItemInventory failed: unknown result");
2716 
 
8363 vikram.rag 2717 
  def getAllAmazonFbaItemInventory(self, ):
2718 
    self.send_getAllAmazonFbaItemInventory()
2719 
    return self.recv_getAllAmazonFbaItemInventory()
8282 kshitij.so 2720 
 
8363 vikram.rag 2721 
  def send_getAllAmazonFbaItemInventory(self, ):
2722 
    self._oprot.writeMessageBegin('getAllAmazonFbaItemInventory', TMessageType.CALL, self._seqid)
2723 
    args = getAllAmazonFbaItemInventory_args()
8282 kshitij.so 2724 
    args.write(self._oprot)
2725 
    self._oprot.writeMessageEnd()
2726 
    self._oprot.trans.flush()
2727 
 
8363 vikram.rag 2728 
  def recv_getAllAmazonFbaItemInventory(self, ):
8282 kshitij.so 2729 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2730 
    if mtype == TMessageType.EXCEPTION:
2731 
      x = TApplicationException()
2732 
      x.read(self._iprot)
2733 
      self._iprot.readMessageEnd()
2734 
      raise x
8363 vikram.rag 2735 
    result = getAllAmazonFbaItemInventory_result()
8282 kshitij.so 2736 
    result.read(self._iprot)
2737 
    self._iprot.readMessageEnd()
2738 
    if result.success is not None:
2739 
      return result.success
8363 vikram.rag 2740 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonFbaItemInventory failed: unknown result");
8282 kshitij.so 2741 
 
8363 vikram.rag 2742 
  def getOursGoodWarehouseIdsForLocation(self, state_id):
2743 
    """
2744 
    Parameters:
2745 
     - state_id
2746 
    """
2747 
    self.send_getOursGoodWarehouseIdsForLocation(state_id)
2748 
    return self.recv_getOursGoodWarehouseIdsForLocation()
8282 kshitij.so 2749 
 
8363 vikram.rag 2750 
  def send_getOursGoodWarehouseIdsForLocation(self, state_id):
2751 
    self._oprot.writeMessageBegin('getOursGoodWarehouseIdsForLocation', TMessageType.CALL, self._seqid)
2752 
    args = getOursGoodWarehouseIdsForLocation_args()
2753 
    args.state_id = state_id
2754 
    args.write(self._oprot)
2755 
    self._oprot.writeMessageEnd()
2756 
    self._oprot.trans.flush()
2757 
 
2758 
  def recv_getOursGoodWarehouseIdsForLocation(self, ):
2759 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2760 
    if mtype == TMessageType.EXCEPTION:
2761 
      x = TApplicationException()
2762 
      x.read(self._iprot)
2763 
      self._iprot.readMessageEnd()
2764 
      raise x
2765 
    result = getOursGoodWarehouseIdsForLocation_result()
2766 
    result.read(self._iprot)
2767 
    self._iprot.readMessageEnd()
2768 
    if result.success is not None:
2769 
      return result.success
2770 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOursGoodWarehouseIdsForLocation failed: unknown result");
2771 
 
8955 vikram.rag 2772 
  def getHoldInventoryDetailForItemForWarehouseIdExceptSource(self, id, warehouse_id, source):
2773 
    """
2774 
    Parameters:
2775 
     - id
2776 
     - warehouse_id
2777 
     - source
2778 
    """
2779 
    self.send_getHoldInventoryDetailForItemForWarehouseIdExceptSource(id, warehouse_id, source)
2780 
    return self.recv_getHoldInventoryDetailForItemForWarehouseIdExceptSource()
8363 vikram.rag 2781 
 
8955 vikram.rag 2782 
  def send_getHoldInventoryDetailForItemForWarehouseIdExceptSource(self, id, warehouse_id, source):
2783 
    self._oprot.writeMessageBegin('getHoldInventoryDetailForItemForWarehouseIdExceptSource', TMessageType.CALL, self._seqid)
2784 
    args = getHoldInventoryDetailForItemForWarehouseIdExceptSource_args()
2785 
    args.id = id
2786 
    args.warehouse_id = warehouse_id
2787 
    args.source = source
2788 
    args.write(self._oprot)
2789 
    self._oprot.writeMessageEnd()
2790 
    self._oprot.trans.flush()
2791 
 
2792 
  def recv_getHoldInventoryDetailForItemForWarehouseIdExceptSource(self, ):
2793 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2794 
    if mtype == TMessageType.EXCEPTION:
2795 
      x = TApplicationException()
2796 
      x.read(self._iprot)
2797 
      self._iprot.readMessageEnd()
2798 
      raise x
2799 
    result = getHoldInventoryDetailForItemForWarehouseIdExceptSource_result()
2800 
    result.read(self._iprot)
2801 
    self._iprot.readMessageEnd()
2802 
    if result.success is not None:
2803 
      return result.success
2804 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getHoldInventoryDetailForItemForWarehouseIdExceptSource failed: unknown result");
2805 
 
9404 vikram.rag 2806 
  def getSnapdealInventoryForItem(self, item_id):
2807 
    """
2808 
    Parameters:
2809 
     - item_id
2810 
    """
2811 
    self.send_getSnapdealInventoryForItem(item_id)
2812 
    return self.recv_getSnapdealInventoryForItem()
8955 vikram.rag 2813 
 
9404 vikram.rag 2814 
  def send_getSnapdealInventoryForItem(self, item_id):
2815 
    self._oprot.writeMessageBegin('getSnapdealInventoryForItem', TMessageType.CALL, self._seqid)
2816 
    args = getSnapdealInventoryForItem_args()
2817 
    args.item_id = item_id
2818 
    args.write(self._oprot)
2819 
    self._oprot.writeMessageEnd()
2820 
    self._oprot.trans.flush()
2821 
 
2822 
  def recv_getSnapdealInventoryForItem(self, ):
2823 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2824 
    if mtype == TMessageType.EXCEPTION:
2825 
      x = TApplicationException()
2826 
      x.read(self._iprot)
2827 
      self._iprot.readMessageEnd()
2828 
      raise x
2829 
    result = getSnapdealInventoryForItem_result()
2830 
    result.read(self._iprot)
2831 
    self._iprot.readMessageEnd()
2832 
    if result.success is not None:
2833 
      return result.success
2834 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealInventoryForItem failed: unknown result");
2835 
 
2836 
  def addOrUpdateSnapdealInventoryForItem(self, snapdealinventoryitem):
2837 
    """
2838 
    Parameters:
2839 
     - snapdealinventoryitem
2840 
    """
2841 
    self.send_addOrUpdateSnapdealInventoryForItem(snapdealinventoryitem)
2842 
    self.recv_addOrUpdateSnapdealInventoryForItem()
2843 
 
2844 
  def send_addOrUpdateSnapdealInventoryForItem(self, snapdealinventoryitem):
2845 
    self._oprot.writeMessageBegin('addOrUpdateSnapdealInventoryForItem', TMessageType.CALL, self._seqid)
2846 
    args = addOrUpdateSnapdealInventoryForItem_args()
2847 
    args.snapdealinventoryitem = snapdealinventoryitem
2848 
    args.write(self._oprot)
2849 
    self._oprot.writeMessageEnd()
2850 
    self._oprot.trans.flush()
2851 
 
2852 
  def recv_addOrUpdateSnapdealInventoryForItem(self, ):
2853 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2854 
    if mtype == TMessageType.EXCEPTION:
2855 
      x = TApplicationException()
2856 
      x.read(self._iprot)
2857 
      self._iprot.readMessageEnd()
2858 
      raise x
2859 
    result = addOrUpdateSnapdealInventoryForItem_result()
2860 
    result.read(self._iprot)
2861 
    self._iprot.readMessageEnd()
2862 
    return
2863 
 
2864 
  def getNlcForWarehouse(self, warehouse_id, item_id):
2865 
    """
2866 
    Parameters:
2867 
     - warehouse_id
2868 
     - item_id
2869 
    """
2870 
    self.send_getNlcForWarehouse(warehouse_id, item_id)
2871 
    return self.recv_getNlcForWarehouse()
2872 
 
2873 
  def send_getNlcForWarehouse(self, warehouse_id, item_id):
2874 
    self._oprot.writeMessageBegin('getNlcForWarehouse', TMessageType.CALL, self._seqid)
2875 
    args = getNlcForWarehouse_args()
2876 
    args.warehouse_id = warehouse_id
2877 
    args.item_id = item_id
2878 
    args.write(self._oprot)
2879 
    self._oprot.writeMessageEnd()
2880 
    self._oprot.trans.flush()
2881 
 
2882 
  def recv_getNlcForWarehouse(self, ):
2883 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2884 
    if mtype == TMessageType.EXCEPTION:
2885 
      x = TApplicationException()
2886 
      x.read(self._iprot)
2887 
      self._iprot.readMessageEnd()
2888 
      raise x
2889 
    result = getNlcForWarehouse_result()
2890 
    result.read(self._iprot)
2891 
    self._iprot.readMessageEnd()
2892 
    if result.success is not None:
2893 
      return result.success
2894 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNlcForWarehouse failed: unknown result");
2895 
 
9640 amar.kumar 2896 
  def getHeldInventoryMapForItem(self, item_id, warehouse_id):
2897 
    """
2898 
    Parameters:
2899 
     - item_id
2900 
     - warehouse_id
2901 
    """
2902 
    self.send_getHeldInventoryMapForItem(item_id, warehouse_id)
2903 
    return self.recv_getHeldInventoryMapForItem()
2904 
 
2905 
  def send_getHeldInventoryMapForItem(self, item_id, warehouse_id):
2906 
    self._oprot.writeMessageBegin('getHeldInventoryMapForItem', TMessageType.CALL, self._seqid)
2907 
    args = getHeldInventoryMapForItem_args()
2908 
    args.item_id = item_id
2909 
    args.warehouse_id = warehouse_id
2910 
    args.write(self._oprot)
2911 
    self._oprot.writeMessageEnd()
2912 
    self._oprot.trans.flush()
2913 
 
2914 
  def recv_getHeldInventoryMapForItem(self, ):
2915 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2916 
    if mtype == TMessageType.EXCEPTION:
2917 
      x = TApplicationException()
2918 
      x.read(self._iprot)
2919 
      self._iprot.readMessageEnd()
2920 
      raise x
2921 
    result = getHeldInventoryMapForItem_result()
2922 
    result.read(self._iprot)
2923 
    self._iprot.readMessageEnd()
2924 
    if result.success is not None:
2925 
      return result.success
2926 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getHeldInventoryMapForItem failed: unknown result");
2927 
 
9495 vikram.rag 2928 
  def addOrUpdateAllAmazonFbaInventory(self, allamazonfbainventorysnapshot):
2929 
    """
2930 
    Parameters:
2931 
     - allamazonfbainventorysnapshot
2932 
    """
2933 
    self.send_addOrUpdateAllAmazonFbaInventory(allamazonfbainventorysnapshot)
2934 
    self.recv_addOrUpdateAllAmazonFbaInventory()
9404 vikram.rag 2935 
 
9495 vikram.rag 2936 
  def send_addOrUpdateAllAmazonFbaInventory(self, allamazonfbainventorysnapshot):
2937 
    self._oprot.writeMessageBegin('addOrUpdateAllAmazonFbaInventory', TMessageType.CALL, self._seqid)
2938 
    args = addOrUpdateAllAmazonFbaInventory_args()
2939 
    args.allamazonfbainventorysnapshot = allamazonfbainventorysnapshot
9456 vikram.rag 2940 
    args.write(self._oprot)
2941 
    self._oprot.writeMessageEnd()
2942 
    self._oprot.trans.flush()
2943 
 
9495 vikram.rag 2944 
  def recv_addOrUpdateAllAmazonFbaInventory(self, ):
9456 vikram.rag 2945 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2946 
    if mtype == TMessageType.EXCEPTION:
2947 
      x = TApplicationException()
2948 
      x.read(self._iprot)
2949 
      self._iprot.readMessageEnd()
2950 
      raise x
9495 vikram.rag 2951 
    result = addOrUpdateAllAmazonFbaInventory_result()
9456 vikram.rag 2952 
    result.read(self._iprot)
2953 
    self._iprot.readMessageEnd()
9495 vikram.rag 2954 
    return
9456 vikram.rag 2955 
 
9495 vikram.rag 2956 
  def addOrUpdateAllSnapdealInventory(self, allsnapdealinventorysnapshot):
9482 vikram.rag 2957 
    """
2958 
    Parameters:
9495 vikram.rag 2959 
     - allsnapdealinventorysnapshot
9482 vikram.rag 2960 
    """
9495 vikram.rag 2961 
    self.send_addOrUpdateAllSnapdealInventory(allsnapdealinventorysnapshot)
2962 
    self.recv_addOrUpdateAllSnapdealInventory()
9456 vikram.rag 2963 
 
9495 vikram.rag 2964 
  def send_addOrUpdateAllSnapdealInventory(self, allsnapdealinventorysnapshot):
2965 
    self._oprot.writeMessageBegin('addOrUpdateAllSnapdealInventory', TMessageType.CALL, self._seqid)
2966 
    args = addOrUpdateAllSnapdealInventory_args()
2967 
    args.allsnapdealinventorysnapshot = allsnapdealinventorysnapshot
9482 vikram.rag 2968 
    args.write(self._oprot)
2969 
    self._oprot.writeMessageEnd()
2970 
    self._oprot.trans.flush()
2971 
 
9495 vikram.rag 2972 
  def recv_addOrUpdateAllSnapdealInventory(self, ):
9482 vikram.rag 2973 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2974 
    if mtype == TMessageType.EXCEPTION:
2975 
      x = TApplicationException()
2976 
      x.read(self._iprot)
2977 
      self._iprot.readMessageEnd()
2978 
      raise x
9495 vikram.rag 2979 
    result = addOrUpdateAllSnapdealInventory_result()
9482 vikram.rag 2980 
    result.read(self._iprot)
2981 
    self._iprot.readMessageEnd()
2982 
    return
2983 
 
9495 vikram.rag 2984 
  def getSnapdealInventorySnapshot(self, ):
2985 
    self.send_getSnapdealInventorySnapshot()
2986 
    return self.recv_getSnapdealInventorySnapshot()
9482 vikram.rag 2987 
 
9495 vikram.rag 2988 
  def send_getSnapdealInventorySnapshot(self, ):
2989 
    self._oprot.writeMessageBegin('getSnapdealInventorySnapshot', TMessageType.CALL, self._seqid)
2990 
    args = getSnapdealInventorySnapshot_args()
2991 
    args.write(self._oprot)
2992 
    self._oprot.writeMessageEnd()
2993 
    self._oprot.trans.flush()
2994 
 
2995 
  def recv_getSnapdealInventorySnapshot(self, ):
2996 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2997 
    if mtype == TMessageType.EXCEPTION:
2998 
      x = TApplicationException()
2999 
      x.read(self._iprot)
3000 
      self._iprot.readMessageEnd()
3001 
      raise x
3002 
    result = getSnapdealInventorySnapshot_result()
3003 
    result.read(self._iprot)
3004 
    self._iprot.readMessageEnd()
3005 
    if result.success is not None:
3006 
      return result.success
3007 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealInventorySnapshot failed: unknown result");
3008 
 
9761 amar.kumar 3009 
  def getHoldInventoryDetails(self, itemId, warehouseId, source):
3010 
    """
3011 
    Parameters:
3012 
     - itemId
3013 
     - warehouseId
3014 
     - source
3015 
    """
3016 
    self.send_getHoldInventoryDetails(itemId, warehouseId, source)
3017 
    return self.recv_getHoldInventoryDetails()
9495 vikram.rag 3018 
 
9761 amar.kumar 3019 
  def send_getHoldInventoryDetails(self, itemId, warehouseId, source):
3020 
    self._oprot.writeMessageBegin('getHoldInventoryDetails', TMessageType.CALL, self._seqid)
3021 
    args = getHoldInventoryDetails_args()
3022 
    args.itemId = itemId
3023 
    args.warehouseId = warehouseId
3024 
    args.source = source
3025 
    args.write(self._oprot)
3026 
    self._oprot.writeMessageEnd()
3027 
    self._oprot.trans.flush()
3028 
 
3029 
  def recv_getHoldInventoryDetails(self, ):
3030 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3031 
    if mtype == TMessageType.EXCEPTION:
3032 
      x = TApplicationException()
3033 
      x.read(self._iprot)
3034 
      self._iprot.readMessageEnd()
3035 
      raise x
3036 
    result = getHoldInventoryDetails_result()
3037 
    result.read(self._iprot)
3038 
    self._iprot.readMessageEnd()
3039 
    if result.success is not None:
3040 
      return result.success
3041 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getHoldInventoryDetails failed: unknown result");
3042 
 
10450 vikram.rag 3043 
  def addOrUpdateFlipkartInventorySnapshot(self, flipkartInventorySnapshot, time):
10050 vikram.rag 3044 
    """
3045 
    Parameters:
3046 
     - flipkartInventorySnapshot
10450 vikram.rag 3047 
     - time
10050 vikram.rag 3048 
    """
10450 vikram.rag 3049 
    self.send_addOrUpdateFlipkartInventorySnapshot(flipkartInventorySnapshot, time)
10050 vikram.rag 3050 
    self.recv_addOrUpdateFlipkartInventorySnapshot()
9761 amar.kumar 3051 
 
10450 vikram.rag 3052 
  def send_addOrUpdateFlipkartInventorySnapshot(self, flipkartInventorySnapshot, time):
10050 vikram.rag 3053 
    self._oprot.writeMessageBegin('addOrUpdateFlipkartInventorySnapshot', TMessageType.CALL, self._seqid)
3054 
    args = addOrUpdateFlipkartInventorySnapshot_args()
3055 
    args.flipkartInventorySnapshot = flipkartInventorySnapshot
10450 vikram.rag 3056 
    args.time = time
10050 vikram.rag 3057 
    args.write(self._oprot)
3058 
    self._oprot.writeMessageEnd()
3059 
    self._oprot.trans.flush()
3060 
 
3061 
  def recv_addOrUpdateFlipkartInventorySnapshot(self, ):
3062 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3063 
    if mtype == TMessageType.EXCEPTION:
3064 
      x = TApplicationException()
3065 
      x.read(self._iprot)
3066 
      self._iprot.readMessageEnd()
3067 
      raise x
3068 
    result = addOrUpdateFlipkartInventorySnapshot_result()
3069 
    result.read(self._iprot)
3070 
    self._iprot.readMessageEnd()
3071 
    return
3072 
 
3073 
  def getFlipkartInventorySnapshot(self, ):
3074 
    self.send_getFlipkartInventorySnapshot()
3075 
    return self.recv_getFlipkartInventorySnapshot()
3076 
 
3077 
  def send_getFlipkartInventorySnapshot(self, ):
3078 
    self._oprot.writeMessageBegin('getFlipkartInventorySnapshot', TMessageType.CALL, self._seqid)
3079 
    args = getFlipkartInventorySnapshot_args()
3080 
    args.write(self._oprot)
3081 
    self._oprot.writeMessageEnd()
3082 
    self._oprot.trans.flush()
3083 
 
3084 
  def recv_getFlipkartInventorySnapshot(self, ):
3085 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3086 
    if mtype == TMessageType.EXCEPTION:
3087 
      x = TApplicationException()
3088 
      x.read(self._iprot)
3089 
      self._iprot.readMessageEnd()
3090 
      raise x
3091 
    result = getFlipkartInventorySnapshot_result()
3092 
    result.read(self._iprot)
3093 
    self._iprot.readMessageEnd()
3094 
    if result.success is not None:
3095 
      return result.success
3096 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartInventorySnapshot failed: unknown result");
3097 
 
10097 kshitij.so 3098 
  def getFlipkartlInventoryForItem(self, item_id):
3099 
    """
3100 
    Parameters:
3101 
     - item_id
3102 
    """
3103 
    self.send_getFlipkartlInventoryForItem(item_id)
3104 
    return self.recv_getFlipkartlInventoryForItem()
10050 vikram.rag 3105 
 
10097 kshitij.so 3106 
  def send_getFlipkartlInventoryForItem(self, item_id):
3107 
    self._oprot.writeMessageBegin('getFlipkartlInventoryForItem', TMessageType.CALL, self._seqid)
3108 
    args = getFlipkartlInventoryForItem_args()
3109 
    args.item_id = item_id
3110 
    args.write(self._oprot)
3111 
    self._oprot.writeMessageEnd()
3112 
    self._oprot.trans.flush()
3113 
 
3114 
  def recv_getFlipkartlInventoryForItem(self, ):
3115 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3116 
    if mtype == TMessageType.EXCEPTION:
3117 
      x = TApplicationException()
3118 
      x.read(self._iprot)
3119 
      self._iprot.readMessageEnd()
3120 
      raise x
3121 
    result = getFlipkartlInventoryForItem_result()
3122 
    result.read(self._iprot)
3123 
    self._iprot.readMessageEnd()
3124 
    if result.success is not None:
3125 
      return result.success
3126 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartlInventoryForItem failed: unknown result");
3127 
 
10485 vikram.rag 3128 
  def getStateMaster(self, ):
3129 
    self.send_getStateMaster()
3130 
    return self.recv_getStateMaster()
10097 kshitij.so 3131 
 
10485 vikram.rag 3132 
  def send_getStateMaster(self, ):
3133 
    self._oprot.writeMessageBegin('getStateMaster', TMessageType.CALL, self._seqid)
3134 
    args = getStateMaster_args()
3135 
    args.write(self._oprot)
3136 
    self._oprot.writeMessageEnd()
3137 
    self._oprot.trans.flush()
3138 
 
3139 
  def recv_getStateMaster(self, ):
3140 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3141 
    if mtype == TMessageType.EXCEPTION:
3142 
      x = TApplicationException()
3143 
      x.read(self._iprot)
3144 
      self._iprot.readMessageEnd()
3145 
      raise x
3146 
    result = getStateMaster_result()
3147 
    result.read(self._iprot)
3148 
    self._iprot.readMessageEnd()
3149 
    if result.success is not None:
3150 
      return result.success
3151 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStateMaster failed: unknown result");
3152 
 
10544 vikram.rag 3153 
  def updateSnapdealStockAtEOD(self, allsnapdealstock):
3154 
    """
3155 
    Parameters:
3156 
     - allsnapdealstock
3157 
    """
3158 
    self.send_updateSnapdealStockAtEOD(allsnapdealstock)
3159 
    self.recv_updateSnapdealStockAtEOD()
10485 vikram.rag 3160 
 
10544 vikram.rag 3161 
  def send_updateSnapdealStockAtEOD(self, allsnapdealstock):
3162 
    self._oprot.writeMessageBegin('updateSnapdealStockAtEOD', TMessageType.CALL, self._seqid)
3163 
    args = updateSnapdealStockAtEOD_args()
3164 
    args.allsnapdealstock = allsnapdealstock
3165 
    args.write(self._oprot)
3166 
    self._oprot.writeMessageEnd()
3167 
    self._oprot.trans.flush()
3168 
 
3169 
  def recv_updateSnapdealStockAtEOD(self, ):
3170 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3171 
    if mtype == TMessageType.EXCEPTION:
3172 
      x = TApplicationException()
3173 
      x.read(self._iprot)
3174 
      self._iprot.readMessageEnd()
3175 
      raise x
3176 
    result = updateSnapdealStockAtEOD_result()
3177 
    result.read(self._iprot)
3178 
    self._iprot.readMessageEnd()
3179 
    return
3180 
 
3181 
  def updateFlipkartStockAtEOD(self, allflipkartstock):
3182 
    """
3183 
    Parameters:
3184 
     - allflipkartstock
3185 
    """
3186 
    self.send_updateFlipkartStockAtEOD(allflipkartstock)
3187 
    self.recv_updateFlipkartStockAtEOD()
3188 
 
3189 
  def send_updateFlipkartStockAtEOD(self, allflipkartstock):
3190 
    self._oprot.writeMessageBegin('updateFlipkartStockAtEOD', TMessageType.CALL, self._seqid)
3191 
    args = updateFlipkartStockAtEOD_args()
3192 
    args.allflipkartstock = allflipkartstock
3193 
    args.write(self._oprot)
3194 
    self._oprot.writeMessageEnd()
3195 
    self._oprot.trans.flush()
3196 
 
3197 
  def recv_updateFlipkartStockAtEOD(self, ):
3198 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3199 
    if mtype == TMessageType.EXCEPTION:
3200 
      x = TApplicationException()
3201 
      x.read(self._iprot)
3202 
      self._iprot.readMessageEnd()
3203 
      raise x
3204 
    result = updateFlipkartStockAtEOD_result()
3205 
    result.read(self._iprot)
3206 
    self._iprot.readMessageEnd()
3207 
    return
3208 
 
12363 kshitij.so 3209 
  def getWanNlcForSource(self, item_id, source):
3210 
    """
3211 
    Parameters:
3212 
     - item_id
3213 
     - source
3214 
    """
3215 
    self.send_getWanNlcForSource(item_id, source)
3216 
    return self.recv_getWanNlcForSource()
10544 vikram.rag 3217 
 
12363 kshitij.so 3218 
  def send_getWanNlcForSource(self, item_id, source):
3219 
    self._oprot.writeMessageBegin('getWanNlcForSource', TMessageType.CALL, self._seqid)
3220 
    args = getWanNlcForSource_args()
3221 
    args.item_id = item_id
3222 
    args.source = source
3223 
    args.write(self._oprot)
3224 
    self._oprot.writeMessageEnd()
3225 
    self._oprot.trans.flush()
3226 
 
3227 
  def recv_getWanNlcForSource(self, ):
3228 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3229 
    if mtype == TMessageType.EXCEPTION:
3230 
      x = TApplicationException()
3231 
      x.read(self._iprot)
3232 
      self._iprot.readMessageEnd()
3233 
      raise x
3234 
    result = getWanNlcForSource_result()
3235 
    result.read(self._iprot)
3236 
    self._iprot.readMessageEnd()
3237 
    if result.success is not None:
3238 
      return result.success
3239 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getWanNlcForSource failed: unknown result");
3240 
 
3241 
  def getAllAvailableAmazonFbaItemInventory(self, ):
3242 
    self.send_getAllAvailableAmazonFbaItemInventory()
3243 
    return self.recv_getAllAvailableAmazonFbaItemInventory()
3244 
 
3245 
  def send_getAllAvailableAmazonFbaItemInventory(self, ):
3246 
    self._oprot.writeMessageBegin('getAllAvailableAmazonFbaItemInventory', TMessageType.CALL, self._seqid)
3247 
    args = getAllAvailableAmazonFbaItemInventory_args()
3248 
    args.write(self._oprot)
3249 
    self._oprot.writeMessageEnd()
3250 
    self._oprot.trans.flush()
3251 
 
3252 
  def recv_getAllAvailableAmazonFbaItemInventory(self, ):
3253 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3254 
    if mtype == TMessageType.EXCEPTION:
3255 
      x = TApplicationException()
3256 
      x.read(self._iprot)
3257 
      self._iprot.readMessageEnd()
3258 
      raise x
3259 
    result = getAllAvailableAmazonFbaItemInventory_result()
3260 
    result.read(self._iprot)
3261 
    self._iprot.readMessageEnd()
3262 
    if result.success is not None:
3263 
      return result.success
3264 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAvailableAmazonFbaItemInventory failed: unknown result");
3265 
 
17990 kshitij.so 3266 
  def updateItemAvailabilityForItemIds(self, itemIds):
3267 
    """
3268 
    Parameters:
3269 
     - itemIds
3270 
    """
3271 
    self.send_updateItemAvailabilityForItemIds(itemIds)
3272 
    return self.recv_updateItemAvailabilityForItemIds()
12363 kshitij.so 3273 
 
17990 kshitij.so 3274 
  def send_updateItemAvailabilityForItemIds(self, itemIds):
3275 
    self._oprot.writeMessageBegin('updateItemAvailabilityForItemIds', TMessageType.CALL, self._seqid)
3276 
    args = updateItemAvailabilityForItemIds_args()
3277 
    args.itemIds = itemIds
3278 
    args.write(self._oprot)
3279 
    self._oprot.writeMessageEnd()
3280 
    self._oprot.trans.flush()
3281 
 
3282 
  def recv_updateItemAvailabilityForItemIds(self, ):
3283 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3284 
    if mtype == TMessageType.EXCEPTION:
3285 
      x = TApplicationException()
3286 
      x.read(self._iprot)
3287 
      self._iprot.readMessageEnd()
3288 
      raise x
3289 
    result = updateItemAvailabilityForItemIds_result()
3290 
    result.read(self._iprot)
3291 
    self._iprot.readMessageEnd()
3292 
    if result.success is not None:
3293 
      return result.success
3294 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemAvailabilityForItemIds failed: unknown result");
3295 
 
19247 kshitij.so 3296 
  def addVendorItemPricingInBulk(self, vendorItemPricingList):
3297 
    """
3298 
    Parameters:
3299 
     - vendorItemPricingList
3300 
    """
3301 
    self.send_addVendorItemPricingInBulk(vendorItemPricingList)
3302 
    return self.recv_addVendorItemPricingInBulk()
17990 kshitij.so 3303 
 
19247 kshitij.so 3304 
  def send_addVendorItemPricingInBulk(self, vendorItemPricingList):
3305 
    self._oprot.writeMessageBegin('addVendorItemPricingInBulk', TMessageType.CALL, self._seqid)
3306 
    args = addVendorItemPricingInBulk_args()
3307 
    args.vendorItemPricingList = vendorItemPricingList
3308 
    args.write(self._oprot)
3309 
    self._oprot.writeMessageEnd()
3310 
    self._oprot.trans.flush()
3311 
 
3312 
  def recv_addVendorItemPricingInBulk(self, ):
3313 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3314 
    if mtype == TMessageType.EXCEPTION:
3315 
      x = TApplicationException()
3316 
      x.read(self._iprot)
3317 
      self._iprot.readMessageEnd()
3318 
      raise x
3319 
    result = addVendorItemPricingInBulk_result()
3320 
    result.read(self._iprot)
3321 
    self._iprot.readMessageEnd()
3322 
    if result.success is not None:
3323 
      return result.success
3324 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addVendorItemPricingInBulk failed: unknown result");
3325 
 
3326 
  def addInventoryInBulk(self, bulkInventoryList):
3327 
    """
3328 
    Parameters:
3329 
     - bulkInventoryList
3330 
    """
3331 
    self.send_addInventoryInBulk(bulkInventoryList)
3332 
    self.recv_addInventoryInBulk()
3333 
 
3334 
  def send_addInventoryInBulk(self, bulkInventoryList):
3335 
    self._oprot.writeMessageBegin('addInventoryInBulk', TMessageType.CALL, self._seqid)
3336 
    args = addInventoryInBulk_args()
3337 
    args.bulkInventoryList = bulkInventoryList
3338 
    args.write(self._oprot)
3339 
    self._oprot.writeMessageEnd()
3340 
    self._oprot.trans.flush()
3341 
 
3342 
  def recv_addInventoryInBulk(self, ):
3343 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3344 
    if mtype == TMessageType.EXCEPTION:
3345 
      x = TApplicationException()
3346 
      x.read(self._iprot)
3347 
      self._iprot.readMessageEnd()
3348 
      raise x
3349 
    result = addInventoryInBulk_result()
3350 
    result.read(self._iprot)
3351 
    self._iprot.readMessageEnd()
3352 
    if result.cex is not None:
3353 
      raise result.cex
3354 
    return
3355 
 
22717 amit.gupta 3356 
  def getFofoAvailability(self, itemIds):
3357 
    """
3358 
    Parameters:
3359 
     - itemIds
3360 
    """
3361 
    self.send_getFofoAvailability(itemIds)
3362 
    return self.recv_getFofoAvailability()
3363 
 
3364 
  def send_getFofoAvailability(self, itemIds):
3365 
    self._oprot.writeMessageBegin('getFofoAvailability', TMessageType.CALL, self._seqid)
3366 
    args = getFofoAvailability_args()
3367 
    args.itemIds = itemIds
3368 
    args.write(self._oprot)
3369 
    self._oprot.writeMessageEnd()
3370 
    self._oprot.trans.flush()
3371 
 
3372 
  def recv_getFofoAvailability(self, ):
3373 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3374 
    if mtype == TMessageType.EXCEPTION:
3375 
      x = TApplicationException()
3376 
      x.read(self._iprot)
3377 
      self._iprot.readMessageEnd()
3378 
      raise x
3379 
    result = getFofoAvailability_result()
3380 
    result.read(self._iprot)
3381 
    self._iprot.readMessageEnd()
3382 
    if result.success is not None:
3383 
      return result.success
3384 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFofoAvailability failed: unknown result");
3385 
 
19413 amit.gupta 3386 
  def getItemLocationAvailabilityCache(self, itemLocations):
3387 
    """
3388 
    Parameters:
3389 
     - itemLocations
3390 
    """
3391 
    self.send_getItemLocationAvailabilityCache(itemLocations)
3392 
    return self.recv_getItemLocationAvailabilityCache()
19247 kshitij.so 3393 
 
19413 amit.gupta 3394 
  def send_getItemLocationAvailabilityCache(self, itemLocations):
3395 
    self._oprot.writeMessageBegin('getItemLocationAvailabilityCache', TMessageType.CALL, self._seqid)
3396 
    args = getItemLocationAvailabilityCache_args()
3397 
    args.itemLocations = itemLocations
3398 
    args.write(self._oprot)
3399 
    self._oprot.writeMessageEnd()
3400 
    self._oprot.trans.flush()
3401 
 
3402 
  def recv_getItemLocationAvailabilityCache(self, ):
3403 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3404 
    if mtype == TMessageType.EXCEPTION:
3405 
      x = TApplicationException()
3406 
      x.read(self._iprot)
3407 
      self._iprot.readMessageEnd()
3408 
      raise x
3409 
    result = getItemLocationAvailabilityCache_result()
3410 
    result.read(self._iprot)
3411 
    self._iprot.readMessageEnd()
3412 
    if result.success is not None:
3413 
      return result.success
3414 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemLocationAvailabilityCache failed: unknown result");
3415 
 
3416 
  def getItemLocationAvailabilityCacheByItemId(self, itemIds):
3417 
    """
3418 
    Parameters:
3419 
     - itemIds
3420 
    """
3421 
    self.send_getItemLocationAvailabilityCacheByItemId(itemIds)
3422 
    return self.recv_getItemLocationAvailabilityCacheByItemId()
3423 
 
3424 
  def send_getItemLocationAvailabilityCacheByItemId(self, itemIds):
3425 
    self._oprot.writeMessageBegin('getItemLocationAvailabilityCacheByItemId', TMessageType.CALL, self._seqid)
3426 
    args = getItemLocationAvailabilityCacheByItemId_args()
3427 
    args.itemIds = itemIds
3428 
    args.write(self._oprot)
3429 
    self._oprot.writeMessageEnd()
3430 
    self._oprot.trans.flush()
3431 
 
3432 
  def recv_getItemLocationAvailabilityCacheByItemId(self, ):
3433 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3434 
    if mtype == TMessageType.EXCEPTION:
3435 
      x = TApplicationException()
3436 
      x.read(self._iprot)
3437 
      self._iprot.readMessageEnd()
3438 
      raise x
3439 
    result = getItemLocationAvailabilityCacheByItemId_result()
3440 
    result.read(self._iprot)
3441 
    self._iprot.readMessageEnd()
3442 
    if result.success is not None:
3443 
      return result.success
3444 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemLocationAvailabilityCacheByItemId failed: unknown result");
3445 
 
19416 amit.gupta 3446 
  def getItemPincodeAvailability(self, itempricing, pincode):
19413 amit.gupta 3447 
    """
3448 
    Parameters:
19416 amit.gupta 3449 
     - itempricing
19413 amit.gupta 3450 
     - pincode
3451 
    """
19416 amit.gupta 3452 
    self.send_getItemPincodeAvailability(itempricing, pincode)
19413 amit.gupta 3453 
    return self.recv_getItemPincodeAvailability()
3454 
 
19416 amit.gupta 3455 
  def send_getItemPincodeAvailability(self, itempricing, pincode):
19413 amit.gupta 3456 
    self._oprot.writeMessageBegin('getItemPincodeAvailability', TMessageType.CALL, self._seqid)
3457 
    args = getItemPincodeAvailability_args()
19416 amit.gupta 3458 
    args.itempricing = itempricing
19413 amit.gupta 3459 
    args.pincode = pincode
3460 
    args.write(self._oprot)
3461 
    self._oprot.writeMessageEnd()
3462 
    self._oprot.trans.flush()
3463 
 
3464 
  def recv_getItemPincodeAvailability(self, ):
3465 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3466 
    if mtype == TMessageType.EXCEPTION:
3467 
      x = TApplicationException()
3468 
      x.read(self._iprot)
3469 
      self._iprot.readMessageEnd()
3470 
      raise x
3471 
    result = getItemPincodeAvailability_result()
3472 
    result.read(self._iprot)
3473 
    self._iprot.readMessageEnd()
3474 
    if result.success is not None:
3475 
      return result.success
3476 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPincodeAvailability failed: unknown result");
3477 
 
3478 
 
5944 mandeep.dh 3479 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
3480 
  def __init__(self, handler):
3481 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
3482 
    self._processMap["addWarehouse"] = Processor.process_addWarehouse
3483 
    self._processMap["addVendor"] = Processor.process_addVendor
3484 
    self._processMap["updateInventoryHistory"] = Processor.process_updateInventoryHistory
3485 
    self._processMap["updateInventory"] = Processor.process_updateInventory
3486 
    self._processMap["addInventory"] = Processor.process_addInventory
3487 
    self._processMap["retireWarehouse"] = Processor.process_retireWarehouse
3488 
    self._processMap["getItemInventoryByItemId"] = Processor.process_getItemInventoryByItemId
3489 
    self._processMap["getItemAvailibilityAtWarehouse"] = Processor.process_getItemAvailibilityAtWarehouse
3490 
    self._processMap["getItemAvailabilityAtLocation"] = Processor.process_getItemAvailabilityAtLocation
3491 
    self._processMap["getAllWarehouses"] = Processor.process_getAllWarehouses
3492 
    self._processMap["getWarehouse"] = Processor.process_getWarehouse
3493 
    self._processMap["getAllItemsForWarehouse"] = Processor.process_getAllItemsForWarehouse
5966 rajveer 3494 
    self._processMap["isOrderBillable"] = Processor.process_isOrderBillable
5944 mandeep.dh 3495 
    self._processMap["reserveItemInWarehouse"] = Processor.process_reserveItemInWarehouse
7968 amar.kumar 3496 
    self._processMap["updateReservationForOrder"] = Processor.process_updateReservationForOrder
5944 mandeep.dh 3497 
    self._processMap["reduceReservationCount"] = Processor.process_reduceReservationCount
3498 
    self._processMap["getItemPricing"] = Processor.process_getItemPricing
3499 
    self._processMap["getAllItemPricing"] = Processor.process_getAllItemPricing
3500 
    self._processMap["addVendorItemPricing"] = Processor.process_addVendorItemPricing
3501 
    self._processMap["getVendor"] = Processor.process_getVendor
3502 
    self._processMap["getAllVendors"] = Processor.process_getAllVendors
3503 
    self._processMap["addVendorItemMapping"] = Processor.process_addVendorItemMapping
3504 
    self._processMap["getVendorItemMappings"] = Processor.process_getVendorItemMappings
3505 
    self._processMap["getPendingOrdersInventory"] = Processor.process_getPendingOrdersInventory
3506 
    self._processMap["getWarehouses"] = Processor.process_getWarehouses
3507 
    self._processMap["resetAvailability"] = Processor.process_resetAvailability
3508 
    self._processMap["resetAvailabilityForWarehouse"] = Processor.process_resetAvailabilityForWarehouse
3509 
    self._processMap["getItemKeysToBeProcessed"] = Processor.process_getItemKeysToBeProcessed
3510 
    self._processMap["markMissedInventoryUpdatesAsProcessed"] = Processor.process_markMissedInventoryUpdatesAsProcessed
3511 
    self._processMap["getIgnoredItemKeys"] = Processor.process_getIgnoredItemKeys
3512 
    self._processMap["addBadInventory"] = Processor.process_addBadInventory
3513 
    self._processMap["getShippingLocations"] = Processor.process_getShippingLocations
3514 
    self._processMap["getAllVendorItemMappings"] = Processor.process_getAllVendorItemMappings
3515 
    self._processMap["getInventorySnapshot"] = Processor.process_getInventorySnapshot
3516 
    self._processMap["clearItemAvailabilityCache"] = Processor.process_clearItemAvailabilityCache
3517 
    self._processMap["updateVendorString"] = Processor.process_updateVendorString
6096 amit.gupta 3518 
    self._processMap["clearItemAvailabilityCacheForItem"] = Processor.process_clearItemAvailabilityCacheForItem
6467 amar.kumar 3519 
    self._processMap["getOurWarehouseIdForVendor"] = Processor.process_getOurWarehouseIdForVendor
6484 amar.kumar 3520 
    self._processMap["getItemAvailabilitiesAtOurWarehouses"] = Processor.process_getItemAvailabilitiesAtOurWarehouses
6531 vikram.rag 3521 
    self._processMap["getMonitoredWarehouseForVendors"] = Processor.process_getMonitoredWarehouseForVendors
3522 
    self._processMap["getIgnoredWarehouseidsAndItemids"] = Processor.process_getIgnoredWarehouseidsAndItemids
3523 
    self._processMap["insertItemtoIgnoreInventoryUpdatelist"] = Processor.process_insertItemtoIgnoreInventoryUpdatelist
3524 
    self._processMap["deleteItemFromIgnoredInventoryUpdateList"] = Processor.process_deleteItemFromIgnoredInventoryUpdateList
3525 
    self._processMap["getAllIgnoredInventoryupdateItemsCount"] = Processor.process_getAllIgnoredInventoryupdateItemsCount
3526 
    self._processMap["getIgnoredInventoryUpdateItemids"] = Processor.process_getIgnoredInventoryUpdateItemids
6821 amar.kumar 3527 
    self._processMap["updateItemStockPurchaseParams"] = Processor.process_updateItemStockPurchaseParams
3528 
    self._processMap["getItemStockPurchaseParams"] = Processor.process_getItemStockPurchaseParams
3529 
    self._processMap["addOosStatusForItem"] = Processor.process_addOosStatusForItem
6832 amar.kumar 3530 
    self._processMap["getOosStatusesForXDaysForItem"] = Processor.process_getOosStatusesForXDaysForItem
10126 amar.kumar 3531 
    self._processMap["getOosStatusesForXDays"] = Processor.process_getOosStatusesForXDays
3532 
    self._processMap["getAllVendorItemPricing"] = Processor.process_getAllVendorItemPricing
6857 amar.kumar 3533 
    self._processMap["getNonZeroItemStockPurchaseParams"] = Processor.process_getNonZeroItemStockPurchaseParams
7149 amar.kumar 3534 
    self._processMap["getBillableInventoryAndPendingOrders"] = Processor.process_getBillableInventoryAndPendingOrders
7281 kshitij.so 3535 
    self._processMap["getWarehouseName"] = Processor.process_getWarehouseName
3536 
    self._processMap["getAmazonInventoryForItem"] = Processor.process_getAmazonInventoryForItem
3537 
    self._processMap["getAllAmazonInventory"] = Processor.process_getAllAmazonInventory
3538 
    self._processMap["addOrUpdateAmazonInventoryForItem"] = Processor.process_addOrUpdateAmazonInventoryForItem
7972 amar.kumar 3539 
    self._processMap["getLastNdaySaleForItem"] = Processor.process_getLastNdaySaleForItem
8282 kshitij.so 3540 
    self._processMap["addOrUpdateAmazonFbaInventory"] = Processor.process_addOrUpdateAmazonFbaInventory
8182 amar.kumar 3541 
    self._processMap["addUpdateHoldInventory"] = Processor.process_addUpdateHoldInventory
8282 kshitij.so 3542 
    self._processMap["getAmazonFbaItemInventory"] = Processor.process_getAmazonFbaItemInventory
8363 vikram.rag 3543 
    self._processMap["getAllAmazonFbaItemInventory"] = Processor.process_getAllAmazonFbaItemInventory
3544 
    self._processMap["getOursGoodWarehouseIdsForLocation"] = Processor.process_getOursGoodWarehouseIdsForLocation
8955 vikram.rag 3545 
    self._processMap["getHoldInventoryDetailForItemForWarehouseIdExceptSource"] = Processor.process_getHoldInventoryDetailForItemForWarehouseIdExceptSource
9404 vikram.rag 3546 
    self._processMap["getSnapdealInventoryForItem"] = Processor.process_getSnapdealInventoryForItem
3547 
    self._processMap["addOrUpdateSnapdealInventoryForItem"] = Processor.process_addOrUpdateSnapdealInventoryForItem
3548 
    self._processMap["getNlcForWarehouse"] = Processor.process_getNlcForWarehouse
9640 amar.kumar 3549 
    self._processMap["getHeldInventoryMapForItem"] = Processor.process_getHeldInventoryMapForItem
9482 vikram.rag 3550 
    self._processMap["addOrUpdateAllAmazonFbaInventory"] = Processor.process_addOrUpdateAllAmazonFbaInventory
9495 vikram.rag 3551 
    self._processMap["addOrUpdateAllSnapdealInventory"] = Processor.process_addOrUpdateAllSnapdealInventory
3552 
    self._processMap["getSnapdealInventorySnapshot"] = Processor.process_getSnapdealInventorySnapshot
9761 amar.kumar 3553 
    self._processMap["getHoldInventoryDetails"] = Processor.process_getHoldInventoryDetails
10050 vikram.rag 3554 
    self._processMap["addOrUpdateFlipkartInventorySnapshot"] = Processor.process_addOrUpdateFlipkartInventorySnapshot
3555 
    self._processMap["getFlipkartInventorySnapshot"] = Processor.process_getFlipkartInventorySnapshot
10097 kshitij.so 3556 
    self._processMap["getFlipkartlInventoryForItem"] = Processor.process_getFlipkartlInventoryForItem
10485 vikram.rag 3557 
    self._processMap["getStateMaster"] = Processor.process_getStateMaster
10544 vikram.rag 3558 
    self._processMap["updateSnapdealStockAtEOD"] = Processor.process_updateSnapdealStockAtEOD
3559 
    self._processMap["updateFlipkartStockAtEOD"] = Processor.process_updateFlipkartStockAtEOD
12363 kshitij.so 3560 
    self._processMap["getWanNlcForSource"] = Processor.process_getWanNlcForSource
3561 
    self._processMap["getAllAvailableAmazonFbaItemInventory"] = Processor.process_getAllAvailableAmazonFbaItemInventory
17990 kshitij.so 3562 
    self._processMap["updateItemAvailabilityForItemIds"] = Processor.process_updateItemAvailabilityForItemIds
19247 kshitij.so 3563 
    self._processMap["addVendorItemPricingInBulk"] = Processor.process_addVendorItemPricingInBulk
3564 
    self._processMap["addInventoryInBulk"] = Processor.process_addInventoryInBulk
22717 amit.gupta 3565 
    self._processMap["getFofoAvailability"] = Processor.process_getFofoAvailability
19413 amit.gupta 3566 
    self._processMap["getItemLocationAvailabilityCache"] = Processor.process_getItemLocationAvailabilityCache
3567 
    self._processMap["getItemLocationAvailabilityCacheByItemId"] = Processor.process_getItemLocationAvailabilityCacheByItemId
3568 
    self._processMap["getItemPincodeAvailability"] = Processor.process_getItemPincodeAvailability
5944 mandeep.dh 3569 
 
3570 
  def process(self, iprot, oprot):
3571 
    (name, type, seqid) = iprot.readMessageBegin()
3572 
    if name not in self._processMap:
3573 
      iprot.skip(TType.STRUCT)
3574 
      iprot.readMessageEnd()
3575 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3576 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3577 
      x.write(oprot)
3578 
      oprot.writeMessageEnd()
3579 
      oprot.trans.flush()
3580 
      return
3581 
    else:
3582 
      self._processMap[name](self, seqid, iprot, oprot)
3583 
    return True
3584 
 
3585 
  def process_addWarehouse(self, seqid, iprot, oprot):
3586 
    args = addWarehouse_args()
3587 
    args.read(iprot)
3588 
    iprot.readMessageEnd()
3589 
    result = addWarehouse_result()
3590 
    try:
3591 
      result.success = self._handler.addWarehouse(args.warehouse)
3592 
    except InventoryServiceException, cex:
3593 
      result.cex = cex
3594 
    oprot.writeMessageBegin("addWarehouse", TMessageType.REPLY, seqid)
3595 
    result.write(oprot)
3596 
    oprot.writeMessageEnd()
3597 
    oprot.trans.flush()
3598 
 
3599 
  def process_addVendor(self, seqid, iprot, oprot):
3600 
    args = addVendor_args()
3601 
    args.read(iprot)
3602 
    iprot.readMessageEnd()
3603 
    result = addVendor_result()
3604 
    try:
3605 
      result.success = self._handler.addVendor(args.vendor)
3606 
    except InventoryServiceException, cex:
3607 
      result.cex = cex
3608 
    oprot.writeMessageBegin("addVendor", TMessageType.REPLY, seqid)
3609 
    result.write(oprot)
3610 
    oprot.writeMessageEnd()
3611 
    oprot.trans.flush()
3612 
 
3613 
  def process_updateInventoryHistory(self, seqid, iprot, oprot):
3614 
    args = updateInventoryHistory_args()
3615 
    args.read(iprot)
3616 
    iprot.readMessageEnd()
3617 
    result = updateInventoryHistory_result()
3618 
    try:
3619 
      self._handler.updateInventoryHistory(args.warehouse_id, args.timestamp, args.availability)
3620 
    except InventoryServiceException, cex:
3621 
      result.cex = cex
3622 
    oprot.writeMessageBegin("updateInventoryHistory", TMessageType.REPLY, seqid)
3623 
    result.write(oprot)
3624 
    oprot.writeMessageEnd()
3625 
    oprot.trans.flush()
3626 
 
3627 
  def process_updateInventory(self, seqid, iprot, oprot):
3628 
    args = updateInventory_args()
3629 
    args.read(iprot)
3630 
    iprot.readMessageEnd()
3631 
    result = updateInventory_result()
3632 
    try:
3633 
      self._handler.updateInventory(args.warehouse_id, args.timestamp, args.availability)
3634 
    except InventoryServiceException, cex:
3635 
      result.cex = cex
3636 
    oprot.writeMessageBegin("updateInventory", TMessageType.REPLY, seqid)
3637 
    result.write(oprot)
3638 
    oprot.writeMessageEnd()
3639 
    oprot.trans.flush()
3640 
 
3641 
  def process_addInventory(self, seqid, iprot, oprot):
3642 
    args = addInventory_args()
3643 
    args.read(iprot)
3644 
    iprot.readMessageEnd()
3645 
    result = addInventory_result()
3646 
    try:
3647 
      self._handler.addInventory(args.itemId, args.warehouseId, args.quantity)
3648 
    except InventoryServiceException, cex:
3649 
      result.cex = cex
3650 
    oprot.writeMessageBegin("addInventory", TMessageType.REPLY, seqid)
3651 
    result.write(oprot)
3652 
    oprot.writeMessageEnd()
3653 
    oprot.trans.flush()
3654 
 
3655 
  def process_retireWarehouse(self, seqid, iprot, oprot):
3656 
    args = retireWarehouse_args()
3657 
    args.read(iprot)
3658 
    iprot.readMessageEnd()
3659 
    result = retireWarehouse_result()
3660 
    try:
3661 
      self._handler.retireWarehouse(args.warehouse_id)
3662 
    except InventoryServiceException, cex:
3663 
      result.cex = cex
3664 
    oprot.writeMessageBegin("retireWarehouse", TMessageType.REPLY, seqid)
3665 
    result.write(oprot)
3666 
    oprot.writeMessageEnd()
3667 
    oprot.trans.flush()
3668 
 
3669 
  def process_getItemInventoryByItemId(self, seqid, iprot, oprot):
3670 
    args = getItemInventoryByItemId_args()
3671 
    args.read(iprot)
3672 
    iprot.readMessageEnd()
3673 
    result = getItemInventoryByItemId_result()
3674 
    try:
3675 
      result.success = self._handler.getItemInventoryByItemId(args.item_id)
3676 
    except InventoryServiceException, cex:
3677 
      result.cex = cex
3678 
    oprot.writeMessageBegin("getItemInventoryByItemId", TMessageType.REPLY, seqid)
3679 
    result.write(oprot)
3680 
    oprot.writeMessageEnd()
3681 
    oprot.trans.flush()
3682 
 
3683 
  def process_getItemAvailibilityAtWarehouse(self, seqid, iprot, oprot):
3684 
    args = getItemAvailibilityAtWarehouse_args()
3685 
    args.read(iprot)
3686 
    iprot.readMessageEnd()
3687 
    result = getItemAvailibilityAtWarehouse_result()
3688 
    try:
3689 
      result.success = self._handler.getItemAvailibilityAtWarehouse(args.warehouse_id, args.item_id)
3690 
    except InventoryServiceException, cex:
3691 
      result.cex = cex
3692 
    oprot.writeMessageBegin("getItemAvailibilityAtWarehouse", TMessageType.REPLY, seqid)
3693 
    result.write(oprot)
3694 
    oprot.writeMessageEnd()
3695 
    oprot.trans.flush()
3696 
 
3697 
  def process_getItemAvailabilityAtLocation(self, seqid, iprot, oprot):
3698 
    args = getItemAvailabilityAtLocation_args()
3699 
    args.read(iprot)
3700 
    iprot.readMessageEnd()
3701 
    result = getItemAvailabilityAtLocation_result()
3702 
    try:
5978 rajveer 3703 
      result.success = self._handler.getItemAvailabilityAtLocation(args.itemId, args.sourceId)
5944 mandeep.dh 3704 
    except InventoryServiceException, isex:
3705 
      result.isex = isex
3706 
    oprot.writeMessageBegin("getItemAvailabilityAtLocation", TMessageType.REPLY, seqid)
3707 
    result.write(oprot)
3708 
    oprot.writeMessageEnd()
3709 
    oprot.trans.flush()
3710 
 
3711 
  def process_getAllWarehouses(self, seqid, iprot, oprot):
3712 
    args = getAllWarehouses_args()
3713 
    args.read(iprot)
3714 
    iprot.readMessageEnd()
3715 
    result = getAllWarehouses_result()
3716 
    try:
3717 
      result.success = self._handler.getAllWarehouses(args.isActive)
3718 
    except InventoryServiceException, cex:
3719 
      result.cex = cex
3720 
    oprot.writeMessageBegin("getAllWarehouses", TMessageType.REPLY, seqid)
3721 
    result.write(oprot)
3722 
    oprot.writeMessageEnd()
3723 
    oprot.trans.flush()
3724 
 
3725 
  def process_getWarehouse(self, seqid, iprot, oprot):
3726 
    args = getWarehouse_args()
3727 
    args.read(iprot)
3728 
    iprot.readMessageEnd()
3729 
    result = getWarehouse_result()
3730 
    try:
3731 
      result.success = self._handler.getWarehouse(args.warehouse_id)
3732 
    except InventoryServiceException, cex:
3733 
      result.cex = cex
3734 
    oprot.writeMessageBegin("getWarehouse", TMessageType.REPLY, seqid)
3735 
    result.write(oprot)
3736 
    oprot.writeMessageEnd()
3737 
    oprot.trans.flush()
3738 
 
3739 
  def process_getAllItemsForWarehouse(self, seqid, iprot, oprot):
3740 
    args = getAllItemsForWarehouse_args()
3741 
    args.read(iprot)
3742 
    iprot.readMessageEnd()
3743 
    result = getAllItemsForWarehouse_result()
3744 
    try:
3745 
      result.success = self._handler.getAllItemsForWarehouse(args.warehouse_id)
3746 
    except InventoryServiceException, cex:
3747 
      result.cex = cex
3748 
    oprot.writeMessageBegin("getAllItemsForWarehouse", TMessageType.REPLY, seqid)
3749 
    result.write(oprot)
3750 
    oprot.writeMessageEnd()
3751 
    oprot.trans.flush()
3752 
 
5966 rajveer 3753 
  def process_isOrderBillable(self, seqid, iprot, oprot):
3754 
    args = isOrderBillable_args()
3755 
    args.read(iprot)
3756 
    iprot.readMessageEnd()
3757 
    result = isOrderBillable_result()
3758 
    result.success = self._handler.isOrderBillable(args.itemId, args.warehouseId, args.sourceId, args.orderId)
3759 
    oprot.writeMessageBegin("isOrderBillable", TMessageType.REPLY, seqid)
3760 
    result.write(oprot)
3761 
    oprot.writeMessageEnd()
3762 
    oprot.trans.flush()
3763 
 
5944 mandeep.dh 3764 
  def process_reserveItemInWarehouse(self, seqid, iprot, oprot):
3765 
    args = reserveItemInWarehouse_args()
3766 
    args.read(iprot)
3767 
    iprot.readMessageEnd()
3768 
    result = reserveItemInWarehouse_result()
3769 
    try:
5966 rajveer 3770 
      result.success = self._handler.reserveItemInWarehouse(args.itemId, args.warehouseId, args.sourceId, args.orderId, args.createdTimestamp, args.promisedShippingTimestamp, args.quantity)
5944 mandeep.dh 3771 
    except InventoryServiceException, cex:
3772 
      result.cex = cex
3773 
    oprot.writeMessageBegin("reserveItemInWarehouse", TMessageType.REPLY, seqid)
3774 
    result.write(oprot)
3775 
    oprot.writeMessageEnd()
3776 
    oprot.trans.flush()
3777 
 
7968 amar.kumar 3778 
  def process_updateReservationForOrder(self, seqid, iprot, oprot):
3779 
    args = updateReservationForOrder_args()
3780 
    args.read(iprot)
3781 
    iprot.readMessageEnd()
3782 
    result = updateReservationForOrder_result()
3783 
    try:
3784 
      result.success = self._handler.updateReservationForOrder(args.itemId, args.warehouseId, args.sourceId, args.orderId, args.createdTimestamp, args.promisedShippingTimestamp, args.quantity)
3785 
    except InventoryServiceException, cex:
3786 
      result.cex = cex
3787 
    oprot.writeMessageBegin("updateReservationForOrder", TMessageType.REPLY, seqid)
3788 
    result.write(oprot)
3789 
    oprot.writeMessageEnd()
3790 
    oprot.trans.flush()
3791 
 
5944 mandeep.dh 3792 
  def process_reduceReservationCount(self, seqid, iprot, oprot):
3793 
    args = reduceReservationCount_args()
3794 
    args.read(iprot)
3795 
    iprot.readMessageEnd()
3796 
    result = reduceReservationCount_result()
3797 
    try:
5966 rajveer 3798 
      result.success = self._handler.reduceReservationCount(args.itemId, args.warehouseId, args.sourceId, args.orderId, args.quantity)
5944 mandeep.dh 3799 
    except InventoryServiceException, cex:
3800 
      result.cex = cex
3801 
    oprot.writeMessageBegin("reduceReservationCount", TMessageType.REPLY, seqid)
3802 
    result.write(oprot)
3803 
    oprot.writeMessageEnd()
3804 
    oprot.trans.flush()
3805 
 
3806 
  def process_getItemPricing(self, seqid, iprot, oprot):
3807 
    args = getItemPricing_args()
3808 
    args.read(iprot)
3809 
    iprot.readMessageEnd()
3810 
    result = getItemPricing_result()
3811 
    try:
3812 
      result.success = self._handler.getItemPricing(args.itemId, args.vendorId)
3813 
    except InventoryServiceException, cex:
3814 
      result.cex = cex
3815 
    oprot.writeMessageBegin("getItemPricing", TMessageType.REPLY, seqid)
3816 
    result.write(oprot)
3817 
    oprot.writeMessageEnd()
3818 
    oprot.trans.flush()
3819 
 
3820 
  def process_getAllItemPricing(self, seqid, iprot, oprot):
3821 
    args = getAllItemPricing_args()
3822 
    args.read(iprot)
3823 
    iprot.readMessageEnd()
3824 
    result = getAllItemPricing_result()
3825 
    try:
3826 
      result.success = self._handler.getAllItemPricing(args.itemId)
3827 
    except InventoryServiceException, cex:
3828 
      result.cex = cex
3829 
    oprot.writeMessageBegin("getAllItemPricing", TMessageType.REPLY, seqid)
3830 
    result.write(oprot)
3831 
    oprot.writeMessageEnd()
3832 
    oprot.trans.flush()
3833 
 
3834 
  def process_addVendorItemPricing(self, seqid, iprot, oprot):
3835 
    args = addVendorItemPricing_args()
3836 
    args.read(iprot)
3837 
    iprot.readMessageEnd()
3838 
    result = addVendorItemPricing_result()
3839 
    try:
3840 
      self._handler.addVendorItemPricing(args.vendorItemPricing)
3841 
    except InventoryServiceException, cex:
3842 
      result.cex = cex
3843 
    oprot.writeMessageBegin("addVendorItemPricing", TMessageType.REPLY, seqid)
3844 
    result.write(oprot)
3845 
    oprot.writeMessageEnd()
3846 
    oprot.trans.flush()
3847 
 
3848 
  def process_getVendor(self, seqid, iprot, oprot):
3849 
    args = getVendor_args()
3850 
    args.read(iprot)
3851 
    iprot.readMessageEnd()
3852 
    result = getVendor_result()
3853 
    result.success = self._handler.getVendor(args.vendorId)
3854 
    oprot.writeMessageBegin("getVendor", TMessageType.REPLY, seqid)
3855 
    result.write(oprot)
3856 
    oprot.writeMessageEnd()
3857 
    oprot.trans.flush()
3858 
 
3859 
  def process_getAllVendors(self, seqid, iprot, oprot):
3860 
    args = getAllVendors_args()
3861 
    args.read(iprot)
3862 
    iprot.readMessageEnd()
3863 
    result = getAllVendors_result()
3864 
    result.success = self._handler.getAllVendors()
3865 
    oprot.writeMessageBegin("getAllVendors", TMessageType.REPLY, seqid)
3866 
    result.write(oprot)
3867 
    oprot.writeMessageEnd()
3868 
    oprot.trans.flush()
3869 
 
3870 
  def process_addVendorItemMapping(self, seqid, iprot, oprot):
3871 
    args = addVendorItemMapping_args()
3872 
    args.read(iprot)
3873 
    iprot.readMessageEnd()
3874 
    result = addVendorItemMapping_result()
3875 
    try:
3876 
      self._handler.addVendorItemMapping(args.key, args.vendorItemMapping)
3877 
    except InventoryServiceException, cex:
3878 
      result.cex = cex
3879 
    oprot.writeMessageBegin("addVendorItemMapping", TMessageType.REPLY, seqid)
3880 
    result.write(oprot)
3881 
    oprot.writeMessageEnd()
3882 
    oprot.trans.flush()
3883 
 
3884 
  def process_getVendorItemMappings(self, seqid, iprot, oprot):
3885 
    args = getVendorItemMappings_args()
3886 
    args.read(iprot)
3887 
    iprot.readMessageEnd()
3888 
    result = getVendorItemMappings_result()
3889 
    try:
3890 
      result.success = self._handler.getVendorItemMappings(args.itemId)
3891 
    except InventoryServiceException, cex:
3892 
      result.cex = cex
3893 
    oprot.writeMessageBegin("getVendorItemMappings", TMessageType.REPLY, seqid)
3894 
    result.write(oprot)
3895 
    oprot.writeMessageEnd()
3896 
    oprot.trans.flush()
3897 
 
3898 
  def process_getPendingOrdersInventory(self, seqid, iprot, oprot):
3899 
    args = getPendingOrdersInventory_args()
3900 
    args.read(iprot)
3901 
    iprot.readMessageEnd()
3902 
    result = getPendingOrdersInventory_result()
3903 
    result.success = self._handler.getPendingOrdersInventory(args.vendorid)
3904 
    oprot.writeMessageBegin("getPendingOrdersInventory", TMessageType.REPLY, seqid)
3905 
    result.write(oprot)
3906 
    oprot.writeMessageEnd()
3907 
    oprot.trans.flush()
3908 
 
3909 
  def process_getWarehouses(self, seqid, iprot, oprot):
3910 
    args = getWarehouses_args()
3911 
    args.read(iprot)
3912 
    iprot.readMessageEnd()
3913 
    result = getWarehouses_result()
3914 
    result.success = self._handler.getWarehouses(args.warehouseType, args.inventoryType, args.vendorId, args.billingWarehouseId, args.shippingWarehouseId)
3915 
    oprot.writeMessageBegin("getWarehouses", TMessageType.REPLY, seqid)
3916 
    result.write(oprot)
3917 
    oprot.writeMessageEnd()
3918 
    oprot.trans.flush()
3919 
 
3920 
  def process_resetAvailability(self, seqid, iprot, oprot):
3921 
    args = resetAvailability_args()
3922 
    args.read(iprot)
3923 
    iprot.readMessageEnd()
3924 
    result = resetAvailability_result()
3925 
    try:
3926 
      self._handler.resetAvailability(args.itemKey, args.vendorId, args.quantity, args.warehouseId)
3927 
    except InventoryServiceException, cex:
3928 
      result.cex = cex
3929 
    oprot.writeMessageBegin("resetAvailability", TMessageType.REPLY, seqid)
3930 
    result.write(oprot)
3931 
    oprot.writeMessageEnd()
3932 
    oprot.trans.flush()
3933 
 
3934 
  def process_resetAvailabilityForWarehouse(self, seqid, iprot, oprot):
3935 
    args = resetAvailabilityForWarehouse_args()
3936 
    args.read(iprot)
3937 
    iprot.readMessageEnd()
3938 
    result = resetAvailabilityForWarehouse_result()
3939 
    try:
3940 
      self._handler.resetAvailabilityForWarehouse(args.warehouseId)
3941 
    except InventoryServiceException, cex:
3942 
      result.cex = cex
3943 
    oprot.writeMessageBegin("resetAvailabilityForWarehouse", TMessageType.REPLY, seqid)
3944 
    result.write(oprot)
3945 
    oprot.writeMessageEnd()
3946 
    oprot.trans.flush()
3947 
 
3948 
  def process_getItemKeysToBeProcessed(self, seqid, iprot, oprot):
3949 
    args = getItemKeysToBeProcessed_args()
3950 
    args.read(iprot)
3951 
    iprot.readMessageEnd()
3952 
    result = getItemKeysToBeProcessed_result()
3953 
    result.success = self._handler.getItemKeysToBeProcessed(args.warehouseId)
3954 
    oprot.writeMessageBegin("getItemKeysToBeProcessed", TMessageType.REPLY, seqid)
3955 
    result.write(oprot)
3956 
    oprot.writeMessageEnd()
3957 
    oprot.trans.flush()
3958 
 
3959 
  def process_markMissedInventoryUpdatesAsProcessed(self, seqid, iprot, oprot):
3960 
    args = markMissedInventoryUpdatesAsProcessed_args()
3961 
    args.read(iprot)
3962 
    iprot.readMessageEnd()
3963 
    result = markMissedInventoryUpdatesAsProcessed_result()
3964 
    self._handler.markMissedInventoryUpdatesAsProcessed(args.itemKey, args.warehouseId)
3965 
    oprot.writeMessageBegin("markMissedInventoryUpdatesAsProcessed", TMessageType.REPLY, seqid)
3966 
    result.write(oprot)
3967 
    oprot.writeMessageEnd()
3968 
    oprot.trans.flush()
3969 
 
3970 
  def process_getIgnoredItemKeys(self, seqid, iprot, oprot):
3971 
    args = getIgnoredItemKeys_args()
3972 
    args.read(iprot)
3973 
    iprot.readMessageEnd()
3974 
    result = getIgnoredItemKeys_result()
3975 
    result.success = self._handler.getIgnoredItemKeys()
3976 
    oprot.writeMessageBegin("getIgnoredItemKeys", TMessageType.REPLY, seqid)
3977 
    result.write(oprot)
3978 
    oprot.writeMessageEnd()
3979 
    oprot.trans.flush()
3980 
 
3981 
  def process_addBadInventory(self, seqid, iprot, oprot):
3982 
    args = addBadInventory_args()
3983 
    args.read(iprot)
3984 
    iprot.readMessageEnd()
3985 
    result = addBadInventory_result()
3986 
    try:
3987 
      self._handler.addBadInventory(args.itemId, args.warehouseId, args.quantity)
3988 
    except InventoryServiceException, cex:
3989 
      result.cex = cex
3990 
    oprot.writeMessageBegin("addBadInventory", TMessageType.REPLY, seqid)
3991 
    result.write(oprot)
3992 
    oprot.writeMessageEnd()
3993 
    oprot.trans.flush()
3994 
 
3995 
  def process_getShippingLocations(self, seqid, iprot, oprot):
3996 
    args = getShippingLocations_args()
3997 
    args.read(iprot)
3998 
    iprot.readMessageEnd()
3999 
    result = getShippingLocations_result()
4000 
    result.success = self._handler.getShippingLocations()
4001 
    oprot.writeMessageBegin("getShippingLocations", TMessageType.REPLY, seqid)
4002 
    result.write(oprot)
4003 
    oprot.writeMessageEnd()
4004 
    oprot.trans.flush()
4005 
 
4006 
  def process_getAllVendorItemMappings(self, seqid, iprot, oprot):
4007 
    args = getAllVendorItemMappings_args()
4008 
    args.read(iprot)
4009 
    iprot.readMessageEnd()
4010 
    result = getAllVendorItemMappings_result()
4011 
    result.success = self._handler.getAllVendorItemMappings()
4012 
    oprot.writeMessageBegin("getAllVendorItemMappings", TMessageType.REPLY, seqid)
4013 
    result.write(oprot)
4014 
    oprot.writeMessageEnd()
4015 
    oprot.trans.flush()
4016 
 
4017 
  def process_getInventorySnapshot(self, seqid, iprot, oprot):
4018 
    args = getInventorySnapshot_args()
4019 
    args.read(iprot)
4020 
    iprot.readMessageEnd()
4021 
    result = getInventorySnapshot_result()
4022 
    result.success = self._handler.getInventorySnapshot(args.warehouseId)
4023 
    oprot.writeMessageBegin("getInventorySnapshot", TMessageType.REPLY, seqid)
4024 
    result.write(oprot)
4025 
    oprot.writeMessageEnd()
4026 
    oprot.trans.flush()
4027 
 
4028 
  def process_clearItemAvailabilityCache(self, seqid, iprot, oprot):
4029 
    args = clearItemAvailabilityCache_args()
4030 
    args.read(iprot)
4031 
    iprot.readMessageEnd()
4032 
    result = clearItemAvailabilityCache_result()
4033 
    self._handler.clearItemAvailabilityCache()
4034 
    oprot.writeMessageBegin("clearItemAvailabilityCache", TMessageType.REPLY, seqid)
4035 
    result.write(oprot)
4036 
    oprot.writeMessageEnd()
4037 
    oprot.trans.flush()
4038 
 
4039 
  def process_updateVendorString(self, seqid, iprot, oprot):
4040 
    args = updateVendorString_args()
4041 
    args.read(iprot)
4042 
    iprot.readMessageEnd()
4043 
    result = updateVendorString_result()
4044 
    self._handler.updateVendorString(args.warehouseId, args.vendorString)
4045 
    oprot.writeMessageBegin("updateVendorString", TMessageType.REPLY, seqid)
4046 
    result.write(oprot)
4047 
    oprot.writeMessageEnd()
4048 
    oprot.trans.flush()
4049 
 
6096 amit.gupta 4050 
  def process_clearItemAvailabilityCacheForItem(self, seqid, iprot, oprot):
4051 
    args = clearItemAvailabilityCacheForItem_args()
4052 
    args.read(iprot)
4053 
    iprot.readMessageEnd()
4054 
    result = clearItemAvailabilityCacheForItem_result()
4055 
    self._handler.clearItemAvailabilityCacheForItem(args.item_id)
4056 
    oprot.writeMessageBegin("clearItemAvailabilityCacheForItem", TMessageType.REPLY, seqid)
4057 
    result.write(oprot)
4058 
    oprot.writeMessageEnd()
4059 
    oprot.trans.flush()
5944 mandeep.dh 4060 
 
6467 amar.kumar 4061 
  def process_getOurWarehouseIdForVendor(self, seqid, iprot, oprot):
4062 
    args = getOurWarehouseIdForVendor_args()
4063 
    args.read(iprot)
4064 
    iprot.readMessageEnd()
4065 
    result = getOurWarehouseIdForVendor_result()
7718 amar.kumar 4066 
    result.success = self._handler.getOurWarehouseIdForVendor(args.vendorId, args.billingWarehouseId)
6467 amar.kumar 4067 
    oprot.writeMessageBegin("getOurWarehouseIdForVendor", TMessageType.REPLY, seqid)
4068 
    result.write(oprot)
4069 
    oprot.writeMessageEnd()
4070 
    oprot.trans.flush()
6096 amit.gupta 4071 
 
6484 amar.kumar 4072 
  def process_getItemAvailabilitiesAtOurWarehouses(self, seqid, iprot, oprot):
4073 
    args = getItemAvailabilitiesAtOurWarehouses_args()
4074 
    args.read(iprot)
4075 
    iprot.readMessageEnd()
4076 
    result = getItemAvailabilitiesAtOurWarehouses_result()
4077 
    result.success = self._handler.getItemAvailabilitiesAtOurWarehouses(args.item_ids)
4078 
    oprot.writeMessageBegin("getItemAvailabilitiesAtOurWarehouses", TMessageType.REPLY, seqid)
4079 
    result.write(oprot)
4080 
    oprot.writeMessageEnd()
4081 
    oprot.trans.flush()
6467 amar.kumar 4082 
 
6531 vikram.rag 4083 
  def process_getMonitoredWarehouseForVendors(self, seqid, iprot, oprot):
4084 
    args = getMonitoredWarehouseForVendors_args()
4085 
    args.read(iprot)
4086 
    iprot.readMessageEnd()
4087 
    result = getMonitoredWarehouseForVendors_result()
4088 
    result.success = self._handler.getMonitoredWarehouseForVendors(args.vendorIds)
4089 
    oprot.writeMessageBegin("getMonitoredWarehouseForVendors", TMessageType.REPLY, seqid)
4090 
    result.write(oprot)
4091 
    oprot.writeMessageEnd()
4092 
    oprot.trans.flush()
6484 amar.kumar 4093 
 
6531 vikram.rag 4094 
  def process_getIgnoredWarehouseidsAndItemids(self, seqid, iprot, oprot):
4095 
    args = getIgnoredWarehouseidsAndItemids_args()
4096 
    args.read(iprot)
4097 
    iprot.readMessageEnd()
4098 
    result = getIgnoredWarehouseidsAndItemids_result()
4099 
    result.success = self._handler.getIgnoredWarehouseidsAndItemids()
4100 
    oprot.writeMessageBegin("getIgnoredWarehouseidsAndItemids", TMessageType.REPLY, seqid)
4101 
    result.write(oprot)
4102 
    oprot.writeMessageEnd()
4103 
    oprot.trans.flush()
4104 
 
4105 
  def process_insertItemtoIgnoreInventoryUpdatelist(self, seqid, iprot, oprot):
4106 
    args = insertItemtoIgnoreInventoryUpdatelist_args()
4107 
    args.read(iprot)
4108 
    iprot.readMessageEnd()
4109 
    result = insertItemtoIgnoreInventoryUpdatelist_result()
4110 
    result.success = self._handler.insertItemtoIgnoreInventoryUpdatelist(args.item_id, args.warehouse_id)
4111 
    oprot.writeMessageBegin("insertItemtoIgnoreInventoryUpdatelist", TMessageType.REPLY, seqid)
4112 
    result.write(oprot)
4113 
    oprot.writeMessageEnd()
4114 
    oprot.trans.flush()
4115 
 
4116 
  def process_deleteItemFromIgnoredInventoryUpdateList(self, seqid, iprot, oprot):
4117 
    args = deleteItemFromIgnoredInventoryUpdateList_args()
4118 
    args.read(iprot)
4119 
    iprot.readMessageEnd()
4120 
    result = deleteItemFromIgnoredInventoryUpdateList_result()
4121 
    result.success = self._handler.deleteItemFromIgnoredInventoryUpdateList(args.item_id, args.warehouse_id)
4122 
    oprot.writeMessageBegin("deleteItemFromIgnoredInventoryUpdateList", TMessageType.REPLY, seqid)
4123 
    result.write(oprot)
4124 
    oprot.writeMessageEnd()
4125 
    oprot.trans.flush()
4126 
 
4127 
  def process_getAllIgnoredInventoryupdateItemsCount(self, seqid, iprot, oprot):
4128 
    args = getAllIgnoredInventoryupdateItemsCount_args()
4129 
    args.read(iprot)
4130 
    iprot.readMessageEnd()
4131 
    result = getAllIgnoredInventoryupdateItemsCount_result()
4132 
    result.success = self._handler.getAllIgnoredInventoryupdateItemsCount()
4133 
    oprot.writeMessageBegin("getAllIgnoredInventoryupdateItemsCount", TMessageType.REPLY, seqid)
4134 
    result.write(oprot)
4135 
    oprot.writeMessageEnd()
4136 
    oprot.trans.flush()
4137 
 
4138 
  def process_getIgnoredInventoryUpdateItemids(self, seqid, iprot, oprot):
4139 
    args = getIgnoredInventoryUpdateItemids_args()
4140 
    args.read(iprot)
4141 
    iprot.readMessageEnd()
4142 
    result = getIgnoredInventoryUpdateItemids_result()
4143 
    result.success = self._handler.getIgnoredInventoryUpdateItemids(args.offset, args.limit)
4144 
    oprot.writeMessageBegin("getIgnoredInventoryUpdateItemids", TMessageType.REPLY, seqid)
4145 
    result.write(oprot)
4146 
    oprot.writeMessageEnd()
4147 
    oprot.trans.flush()
4148 
 
6821 amar.kumar 4149 
  def process_updateItemStockPurchaseParams(self, seqid, iprot, oprot):
4150 
    args = updateItemStockPurchaseParams_args()
4151 
    args.read(iprot)
4152 
    iprot.readMessageEnd()
4153 
    result = updateItemStockPurchaseParams_result()
4154 
    self._handler.updateItemStockPurchaseParams(args.item_id, args.numOfDaysStock, args.minStockLevel)
4155 
    oprot.writeMessageBegin("updateItemStockPurchaseParams", TMessageType.REPLY, seqid)
4156 
    result.write(oprot)
4157 
    oprot.writeMessageEnd()
4158 
    oprot.trans.flush()
6531 vikram.rag 4159 
 
6821 amar.kumar 4160 
  def process_getItemStockPurchaseParams(self, seqid, iprot, oprot):
4161 
    args = getItemStockPurchaseParams_args()
4162 
    args.read(iprot)
4163 
    iprot.readMessageEnd()
4164 
    result = getItemStockPurchaseParams_result()
4165 
    result.success = self._handler.getItemStockPurchaseParams(args.itemId)
4166 
    oprot.writeMessageBegin("getItemStockPurchaseParams", TMessageType.REPLY, seqid)
4167 
    result.write(oprot)
4168 
    oprot.writeMessageEnd()
4169 
    oprot.trans.flush()
4170 
 
4171 
  def process_addOosStatusForItem(self, seqid, iprot, oprot):
4172 
    args = addOosStatusForItem_args()
4173 
    args.read(iprot)
4174 
    iprot.readMessageEnd()
4175 
    result = addOosStatusForItem_result()
4176 
    self._handler.addOosStatusForItem(args.oosStatusMap, args.date)
4177 
    oprot.writeMessageBegin("addOosStatusForItem", TMessageType.REPLY, seqid)
4178 
    result.write(oprot)
4179 
    oprot.writeMessageEnd()
4180 
    oprot.trans.flush()
4181 
 
6832 amar.kumar 4182 
  def process_getOosStatusesForXDaysForItem(self, seqid, iprot, oprot):
4183 
    args = getOosStatusesForXDaysForItem_args()
4184 
    args.read(iprot)
4185 
    iprot.readMessageEnd()
4186 
    result = getOosStatusesForXDaysForItem_result()
9762 amar.kumar 4187 
    result.success = self._handler.getOosStatusesForXDaysForItem(args.itemId, args.sourceId, args.days)
6832 amar.kumar 4188 
    oprot.writeMessageBegin("getOosStatusesForXDaysForItem", TMessageType.REPLY, seqid)
4189 
    result.write(oprot)
4190 
    oprot.writeMessageEnd()
4191 
    oprot.trans.flush()
6821 amar.kumar 4192 
 
10126 amar.kumar 4193 
  def process_getOosStatusesForXDays(self, seqid, iprot, oprot):
4194 
    args = getOosStatusesForXDays_args()
4195 
    args.read(iprot)
4196 
    iprot.readMessageEnd()
4197 
    result = getOosStatusesForXDays_result()
4198 
    result.success = self._handler.getOosStatusesForXDays(args.sourceId, args.days)
4199 
    oprot.writeMessageBegin("getOosStatusesForXDays", TMessageType.REPLY, seqid)
4200 
    result.write(oprot)
4201 
    oprot.writeMessageEnd()
4202 
    oprot.trans.flush()
4203 
 
4204 
  def process_getAllVendorItemPricing(self, seqid, iprot, oprot):
4205 
    args = getAllVendorItemPricing_args()
4206 
    args.read(iprot)
4207 
    iprot.readMessageEnd()
4208 
    result = getAllVendorItemPricing_result()
4209 
    result.success = self._handler.getAllVendorItemPricing(args.itemId, args.vendorId)
4210 
    oprot.writeMessageBegin("getAllVendorItemPricing", TMessageType.REPLY, seqid)
4211 
    result.write(oprot)
4212 
    oprot.writeMessageEnd()
4213 
    oprot.trans.flush()
4214 
 
6857 amar.kumar 4215 
  def process_getNonZeroItemStockPurchaseParams(self, seqid, iprot, oprot):
4216 
    args = getNonZeroItemStockPurchaseParams_args()
4217 
    args.read(iprot)
4218 
    iprot.readMessageEnd()
4219 
    result = getNonZeroItemStockPurchaseParams_result()
4220 
    result.success = self._handler.getNonZeroItemStockPurchaseParams()
4221 
    oprot.writeMessageBegin("getNonZeroItemStockPurchaseParams", TMessageType.REPLY, seqid)
4222 
    result.write(oprot)
4223 
    oprot.writeMessageEnd()
4224 
    oprot.trans.flush()
6832 amar.kumar 4225 
 
7149 amar.kumar 4226 
  def process_getBillableInventoryAndPendingOrders(self, seqid, iprot, oprot):
4227 
    args = getBillableInventoryAndPendingOrders_args()
4228 
    args.read(iprot)
4229 
    iprot.readMessageEnd()
4230 
    result = getBillableInventoryAndPendingOrders_result()
4231 
    result.success = self._handler.getBillableInventoryAndPendingOrders()
4232 
    oprot.writeMessageBegin("getBillableInventoryAndPendingOrders", TMessageType.REPLY, seqid)
4233 
    result.write(oprot)
4234 
    oprot.writeMessageEnd()
4235 
    oprot.trans.flush()
6857 amar.kumar 4236 
 
7281 kshitij.so 4237 
  def process_getWarehouseName(self, seqid, iprot, oprot):
4238 
    args = getWarehouseName_args()
4239 
    args.read(iprot)
4240 
    iprot.readMessageEnd()
4241 
    result = getWarehouseName_result()
4242 
    result.success = self._handler.getWarehouseName(args.warehouse_id)
4243 
    oprot.writeMessageBegin("getWarehouseName", TMessageType.REPLY, seqid)
4244 
    result.write(oprot)
4245 
    oprot.writeMessageEnd()
4246 
    oprot.trans.flush()
7149 amar.kumar 4247 
 
7281 kshitij.so 4248 
  def process_getAmazonInventoryForItem(self, seqid, iprot, oprot):
4249 
    args = getAmazonInventoryForItem_args()
4250 
    args.read(iprot)
4251 
    iprot.readMessageEnd()
4252 
    result = getAmazonInventoryForItem_result()
4253 
    result.success = self._handler.getAmazonInventoryForItem(args.item_id)
4254 
    oprot.writeMessageBegin("getAmazonInventoryForItem", TMessageType.REPLY, seqid)
4255 
    result.write(oprot)
4256 
    oprot.writeMessageEnd()
4257 
    oprot.trans.flush()
4258 
 
4259 
  def process_getAllAmazonInventory(self, seqid, iprot, oprot):
4260 
    args = getAllAmazonInventory_args()
4261 
    args.read(iprot)
4262 
    iprot.readMessageEnd()
4263 
    result = getAllAmazonInventory_result()
4264 
    result.success = self._handler.getAllAmazonInventory()
4265 
    oprot.writeMessageBegin("getAllAmazonInventory", TMessageType.REPLY, seqid)
4266 
    result.write(oprot)
4267 
    oprot.writeMessageEnd()
4268 
    oprot.trans.flush()
4269 
 
4270 
  def process_addOrUpdateAmazonInventoryForItem(self, seqid, iprot, oprot):
4271 
    args = addOrUpdateAmazonInventoryForItem_args()
4272 
    args.read(iprot)
4273 
    iprot.readMessageEnd()
4274 
    result = addOrUpdateAmazonInventoryForItem_result()
10450 vikram.rag 4275 
    self._handler.addOrUpdateAmazonInventoryForItem(args.amazonInventorySnapshot, args.time)
7281 kshitij.so 4276 
    oprot.writeMessageBegin("addOrUpdateAmazonInventoryForItem", TMessageType.REPLY, seqid)
4277 
    result.write(oprot)
4278 
    oprot.writeMessageEnd()
4279 
    oprot.trans.flush()
4280 
 
7972 amar.kumar 4281 
  def process_getLastNdaySaleForItem(self, seqid, iprot, oprot):
4282 
    args = getLastNdaySaleForItem_args()
4283 
    args.read(iprot)
4284 
    iprot.readMessageEnd()
4285 
    result = getLastNdaySaleForItem_result()
4286 
    result.success = self._handler.getLastNdaySaleForItem(args.itemId, args.numberOfDays)
4287 
    oprot.writeMessageBegin("getLastNdaySaleForItem", TMessageType.REPLY, seqid)
4288 
    result.write(oprot)
4289 
    oprot.writeMessageEnd()
4290 
    oprot.trans.flush()
7281 kshitij.so 4291 
 
8282 kshitij.so 4292 
  def process_addOrUpdateAmazonFbaInventory(self, seqid, iprot, oprot):
4293 
    args = addOrUpdateAmazonFbaInventory_args()
4294 
    args.read(iprot)
4295 
    iprot.readMessageEnd()
4296 
    result = addOrUpdateAmazonFbaInventory_result()
4297 
    self._handler.addOrUpdateAmazonFbaInventory(args.amazonfbainventorysnapshot)
4298 
    oprot.writeMessageBegin("addOrUpdateAmazonFbaInventory", TMessageType.REPLY, seqid)
4299 
    result.write(oprot)
4300 
    oprot.writeMessageEnd()
4301 
    oprot.trans.flush()
4302 
 
8182 amar.kumar 4303 
  def process_addUpdateHoldInventory(self, seqid, iprot, oprot):
4304 
    args = addUpdateHoldInventory_args()
4305 
    args.read(iprot)
4306 
    iprot.readMessageEnd()
4307 
    result = addUpdateHoldInventory_result()
9762 amar.kumar 4308 
    try:
4309 
      self._handler.addUpdateHoldInventory(args.itemId, args.warehouseId, args.holdQuantity, args.source)
4310 
    except InventoryServiceException, cex:
4311 
      result.cex = cex
8182 amar.kumar 4312 
    oprot.writeMessageBegin("addUpdateHoldInventory", TMessageType.REPLY, seqid)
4313 
    result.write(oprot)
4314 
    oprot.writeMessageEnd()
4315 
    oprot.trans.flush()
7972 amar.kumar 4316 
 
8282 kshitij.so 4317 
  def process_getAmazonFbaItemInventory(self, seqid, iprot, oprot):
4318 
    args = getAmazonFbaItemInventory_args()
4319 
    args.read(iprot)
4320 
    iprot.readMessageEnd()
4321 
    result = getAmazonFbaItemInventory_result()
4322 
    result.success = self._handler.getAmazonFbaItemInventory(args.itemId)
4323 
    oprot.writeMessageBegin("getAmazonFbaItemInventory", TMessageType.REPLY, seqid)
4324 
    result.write(oprot)
4325 
    oprot.writeMessageEnd()
4326 
    oprot.trans.flush()
8182 amar.kumar 4327 
 
8363 vikram.rag 4328 
  def process_getAllAmazonFbaItemInventory(self, seqid, iprot, oprot):
4329 
    args = getAllAmazonFbaItemInventory_args()
8282 kshitij.so 4330 
    args.read(iprot)
4331 
    iprot.readMessageEnd()
8363 vikram.rag 4332 
    result = getAllAmazonFbaItemInventory_result()
4333 
    result.success = self._handler.getAllAmazonFbaItemInventory()
4334 
    oprot.writeMessageBegin("getAllAmazonFbaItemInventory", TMessageType.REPLY, seqid)
8282 kshitij.so 4335 
    result.write(oprot)
4336 
    oprot.writeMessageEnd()
4337 
    oprot.trans.flush()
4338 
 
8363 vikram.rag 4339 
  def process_getOursGoodWarehouseIdsForLocation(self, seqid, iprot, oprot):
4340 
    args = getOursGoodWarehouseIdsForLocation_args()
4341 
    args.read(iprot)
4342 
    iprot.readMessageEnd()
4343 
    result = getOursGoodWarehouseIdsForLocation_result()
4344 
    result.success = self._handler.getOursGoodWarehouseIdsForLocation(args.state_id)
4345 
    oprot.writeMessageBegin("getOursGoodWarehouseIdsForLocation", TMessageType.REPLY, seqid)
4346 
    result.write(oprot)
4347 
    oprot.writeMessageEnd()
4348 
    oprot.trans.flush()
8282 kshitij.so 4349 
 
8955 vikram.rag 4350 
  def process_getHoldInventoryDetailForItemForWarehouseIdExceptSource(self, seqid, iprot, oprot):
4351 
    args = getHoldInventoryDetailForItemForWarehouseIdExceptSource_args()
4352 
    args.read(iprot)
4353 
    iprot.readMessageEnd()
4354 
    result = getHoldInventoryDetailForItemForWarehouseIdExceptSource_result()
4355 
    result.success = self._handler.getHoldInventoryDetailForItemForWarehouseIdExceptSource(args.id, args.warehouse_id, args.source)
4356 
    oprot.writeMessageBegin("getHoldInventoryDetailForItemForWarehouseIdExceptSource", TMessageType.REPLY, seqid)
4357 
    result.write(oprot)
4358 
    oprot.writeMessageEnd()
4359 
    oprot.trans.flush()
8363 vikram.rag 4360 
 
9404 vikram.rag 4361 
  def process_getSnapdealInventoryForItem(self, seqid, iprot, oprot):
4362 
    args = getSnapdealInventoryForItem_args()
4363 
    args.read(iprot)
4364 
    iprot.readMessageEnd()
4365 
    result = getSnapdealInventoryForItem_result()
4366 
    result.success = self._handler.getSnapdealInventoryForItem(args.item_id)
4367 
    oprot.writeMessageBegin("getSnapdealInventoryForItem", TMessageType.REPLY, seqid)
4368 
    result.write(oprot)
4369 
    oprot.writeMessageEnd()
4370 
    oprot.trans.flush()
8955 vikram.rag 4371 
 
9404 vikram.rag 4372 
  def process_addOrUpdateSnapdealInventoryForItem(self, seqid, iprot, oprot):
4373 
    args = addOrUpdateSnapdealInventoryForItem_args()
4374 
    args.read(iprot)
4375 
    iprot.readMessageEnd()
4376 
    result = addOrUpdateSnapdealInventoryForItem_result()
4377 
    self._handler.addOrUpdateSnapdealInventoryForItem(args.snapdealinventoryitem)
4378 
    oprot.writeMessageBegin("addOrUpdateSnapdealInventoryForItem", TMessageType.REPLY, seqid)
4379 
    result.write(oprot)
4380 
    oprot.writeMessageEnd()
4381 
    oprot.trans.flush()
4382 
 
4383 
  def process_getNlcForWarehouse(self, seqid, iprot, oprot):
4384 
    args = getNlcForWarehouse_args()
4385 
    args.read(iprot)
4386 
    iprot.readMessageEnd()
4387 
    result = getNlcForWarehouse_result()
4388 
    result.success = self._handler.getNlcForWarehouse(args.warehouse_id, args.item_id)
4389 
    oprot.writeMessageBegin("getNlcForWarehouse", TMessageType.REPLY, seqid)
4390 
    result.write(oprot)
4391 
    oprot.writeMessageEnd()
4392 
    oprot.trans.flush()
4393 
 
9640 amar.kumar 4394 
  def process_getHeldInventoryMapForItem(self, seqid, iprot, oprot):
4395 
    args = getHeldInventoryMapForItem_args()
4396 
    args.read(iprot)
4397 
    iprot.readMessageEnd()
4398 
    result = getHeldInventoryMapForItem_result()
4399 
    result.success = self._handler.getHeldInventoryMapForItem(args.item_id, args.warehouse_id)
4400 
    oprot.writeMessageBegin("getHeldInventoryMapForItem", TMessageType.REPLY, seqid)
4401 
    result.write(oprot)
4402 
    oprot.writeMessageEnd()
4403 
    oprot.trans.flush()
4404 
 
9495 vikram.rag 4405 
  def process_addOrUpdateAllAmazonFbaInventory(self, seqid, iprot, oprot):
4406 
    args = addOrUpdateAllAmazonFbaInventory_args()
9456 vikram.rag 4407 
    args.read(iprot)
4408 
    iprot.readMessageEnd()
9495 vikram.rag 4409 
    result = addOrUpdateAllAmazonFbaInventory_result()
4410 
    self._handler.addOrUpdateAllAmazonFbaInventory(args.allamazonfbainventorysnapshot)
4411 
    oprot.writeMessageBegin("addOrUpdateAllAmazonFbaInventory", TMessageType.REPLY, seqid)
9456 vikram.rag 4412 
    result.write(oprot)
4413 
    oprot.writeMessageEnd()
4414 
    oprot.trans.flush()
9404 vikram.rag 4415 
 
9495 vikram.rag 4416 
  def process_addOrUpdateAllSnapdealInventory(self, seqid, iprot, oprot):
4417 
    args = addOrUpdateAllSnapdealInventory_args()
9482 vikram.rag 4418 
    args.read(iprot)
4419 
    iprot.readMessageEnd()
9495 vikram.rag 4420 
    result = addOrUpdateAllSnapdealInventory_result()
4421 
    self._handler.addOrUpdateAllSnapdealInventory(args.allsnapdealinventorysnapshot)
4422 
    oprot.writeMessageBegin("addOrUpdateAllSnapdealInventory", TMessageType.REPLY, seqid)
9482 vikram.rag 4423 
    result.write(oprot)
4424 
    oprot.writeMessageEnd()
4425 
    oprot.trans.flush()
9456 vikram.rag 4426 
 
9495 vikram.rag 4427 
  def process_getSnapdealInventorySnapshot(self, seqid, iprot, oprot):
4428 
    args = getSnapdealInventorySnapshot_args()
4429 
    args.read(iprot)
4430 
    iprot.readMessageEnd()
4431 
    result = getSnapdealInventorySnapshot_result()
4432 
    result.success = self._handler.getSnapdealInventorySnapshot()
4433 
    oprot.writeMessageBegin("getSnapdealInventorySnapshot", TMessageType.REPLY, seqid)
4434 
    result.write(oprot)
4435 
    oprot.writeMessageEnd()
4436 
    oprot.trans.flush()
9482 vikram.rag 4437 
 
9761 amar.kumar 4438 
  def process_getHoldInventoryDetails(self, seqid, iprot, oprot):
4439 
    args = getHoldInventoryDetails_args()
4440 
    args.read(iprot)
4441 
    iprot.readMessageEnd()
4442 
    result = getHoldInventoryDetails_result()
4443 
    result.success = self._handler.getHoldInventoryDetails(args.itemId, args.warehouseId, args.source)
4444 
    oprot.writeMessageBegin("getHoldInventoryDetails", TMessageType.REPLY, seqid)
4445 
    result.write(oprot)
4446 
    oprot.writeMessageEnd()
4447 
    oprot.trans.flush()
9495 vikram.rag 4448 
 
10050 vikram.rag 4449 
  def process_addOrUpdateFlipkartInventorySnapshot(self, seqid, iprot, oprot):
4450 
    args = addOrUpdateFlipkartInventorySnapshot_args()
4451 
    args.read(iprot)
4452 
    iprot.readMessageEnd()
4453 
    result = addOrUpdateFlipkartInventorySnapshot_result()
10450 vikram.rag 4454 
    self._handler.addOrUpdateFlipkartInventorySnapshot(args.flipkartInventorySnapshot, args.time)
10050 vikram.rag 4455 
    oprot.writeMessageBegin("addOrUpdateFlipkartInventorySnapshot", TMessageType.REPLY, seqid)
4456 
    result.write(oprot)
4457 
    oprot.writeMessageEnd()
4458 
    oprot.trans.flush()
9761 amar.kumar 4459 
 
10050 vikram.rag 4460 
  def process_getFlipkartInventorySnapshot(self, seqid, iprot, oprot):
4461 
    args = getFlipkartInventorySnapshot_args()
4462 
    args.read(iprot)
4463 
    iprot.readMessageEnd()
4464 
    result = getFlipkartInventorySnapshot_result()
4465 
    result.success = self._handler.getFlipkartInventorySnapshot()
4466 
    oprot.writeMessageBegin("getFlipkartInventorySnapshot", TMessageType.REPLY, seqid)
4467 
    result.write(oprot)
4468 
    oprot.writeMessageEnd()
4469 
    oprot.trans.flush()
4470 
 
10097 kshitij.so 4471 
  def process_getFlipkartlInventoryForItem(self, seqid, iprot, oprot):
4472 
    args = getFlipkartlInventoryForItem_args()
4473 
    args.read(iprot)
4474 
    iprot.readMessageEnd()
4475 
    result = getFlipkartlInventoryForItem_result()
4476 
    result.success = self._handler.getFlipkartlInventoryForItem(args.item_id)
4477 
    oprot.writeMessageBegin("getFlipkartlInventoryForItem", TMessageType.REPLY, seqid)
4478 
    result.write(oprot)
4479 
    oprot.writeMessageEnd()
4480 
    oprot.trans.flush()
10050 vikram.rag 4481 
 
10485 vikram.rag 4482 
  def process_getStateMaster(self, seqid, iprot, oprot):
4483 
    args = getStateMaster_args()
4484 
    args.read(iprot)
4485 
    iprot.readMessageEnd()
4486 
    result = getStateMaster_result()
4487 
    result.success = self._handler.getStateMaster()
4488 
    oprot.writeMessageBegin("getStateMaster", TMessageType.REPLY, seqid)
4489 
    result.write(oprot)
4490 
    oprot.writeMessageEnd()
4491 
    oprot.trans.flush()
10097 kshitij.so 4492 
 
10544 vikram.rag 4493 
  def process_updateSnapdealStockAtEOD(self, seqid, iprot, oprot):
4494 
    args = updateSnapdealStockAtEOD_args()
4495 
    args.read(iprot)
4496 
    iprot.readMessageEnd()
4497 
    result = updateSnapdealStockAtEOD_result()
4498 
    self._handler.updateSnapdealStockAtEOD(args.allsnapdealstock)
4499 
    oprot.writeMessageBegin("updateSnapdealStockAtEOD", TMessageType.REPLY, seqid)
4500 
    result.write(oprot)
4501 
    oprot.writeMessageEnd()
4502 
    oprot.trans.flush()
10485 vikram.rag 4503 
 
10544 vikram.rag 4504 
  def process_updateFlipkartStockAtEOD(self, seqid, iprot, oprot):
4505 
    args = updateFlipkartStockAtEOD_args()
4506 
    args.read(iprot)
4507 
    iprot.readMessageEnd()
4508 
    result = updateFlipkartStockAtEOD_result()
4509 
    self._handler.updateFlipkartStockAtEOD(args.allflipkartstock)
4510 
    oprot.writeMessageBegin("updateFlipkartStockAtEOD", TMessageType.REPLY, seqid)
4511 
    result.write(oprot)
4512 
    oprot.writeMessageEnd()
4513 
    oprot.trans.flush()
4514 
 
12363 kshitij.so 4515 
  def process_getWanNlcForSource(self, seqid, iprot, oprot):
4516 
    args = getWanNlcForSource_args()
4517 
    args.read(iprot)
4518 
    iprot.readMessageEnd()
4519 
    result = getWanNlcForSource_result()
4520 
    result.success = self._handler.getWanNlcForSource(args.item_id, args.source)
4521 
    oprot.writeMessageBegin("getWanNlcForSource", TMessageType.REPLY, seqid)
4522 
    result.write(oprot)
4523 
    oprot.writeMessageEnd()
4524 
    oprot.trans.flush()
10544 vikram.rag 4525 
 
12363 kshitij.so 4526 
  def process_getAllAvailableAmazonFbaItemInventory(self, seqid, iprot, oprot):
4527 
    args = getAllAvailableAmazonFbaItemInventory_args()
4528 
    args.read(iprot)
4529 
    iprot.readMessageEnd()
4530 
    result = getAllAvailableAmazonFbaItemInventory_result()
4531 
    result.success = self._handler.getAllAvailableAmazonFbaItemInventory()
4532 
    oprot.writeMessageBegin("getAllAvailableAmazonFbaItemInventory", TMessageType.REPLY, seqid)
4533 
    result.write(oprot)
4534 
    oprot.writeMessageEnd()
4535 
    oprot.trans.flush()
4536 
 
17990 kshitij.so 4537 
  def process_updateItemAvailabilityForItemIds(self, seqid, iprot, oprot):
4538 
    args = updateItemAvailabilityForItemIds_args()
4539 
    args.read(iprot)
4540 
    iprot.readMessageEnd()
4541 
    result = updateItemAvailabilityForItemIds_result()
4542 
    result.success = self._handler.updateItemAvailabilityForItemIds(args.itemIds)
4543 
    oprot.writeMessageBegin("updateItemAvailabilityForItemIds", TMessageType.REPLY, seqid)
4544 
    result.write(oprot)
4545 
    oprot.writeMessageEnd()
4546 
    oprot.trans.flush()
12363 kshitij.so 4547 
 
19247 kshitij.so 4548 
  def process_addVendorItemPricingInBulk(self, seqid, iprot, oprot):
4549 
    args = addVendorItemPricingInBulk_args()
4550 
    args.read(iprot)
4551 
    iprot.readMessageEnd()
4552 
    result = addVendorItemPricingInBulk_result()
4553 
    result.success = self._handler.addVendorItemPricingInBulk(args.vendorItemPricingList)
4554 
    oprot.writeMessageBegin("addVendorItemPricingInBulk", TMessageType.REPLY, seqid)
4555 
    result.write(oprot)
4556 
    oprot.writeMessageEnd()
4557 
    oprot.trans.flush()
17990 kshitij.so 4558 
 
19247 kshitij.so 4559 
  def process_addInventoryInBulk(self, seqid, iprot, oprot):
4560 
    args = addInventoryInBulk_args()
4561 
    args.read(iprot)
4562 
    iprot.readMessageEnd()
4563 
    result = addInventoryInBulk_result()
4564 
    try:
4565 
      self._handler.addInventoryInBulk(args.bulkInventoryList)
4566 
    except InventoryServiceException, cex:
4567 
      result.cex = cex
4568 
    oprot.writeMessageBegin("addInventoryInBulk", TMessageType.REPLY, seqid)
4569 
    result.write(oprot)
4570 
    oprot.writeMessageEnd()
4571 
    oprot.trans.flush()
4572 
 
22717 amit.gupta 4573 
  def process_getFofoAvailability(self, seqid, iprot, oprot):
4574 
    args = getFofoAvailability_args()
4575 
    args.read(iprot)
4576 
    iprot.readMessageEnd()
4577 
    result = getFofoAvailability_result()
4578 
    result.success = self._handler.getFofoAvailability(args.itemIds)
4579 
    oprot.writeMessageBegin("getFofoAvailability", TMessageType.REPLY, seqid)
4580 
    result.write(oprot)
4581 
    oprot.writeMessageEnd()
4582 
    oprot.trans.flush()
4583 
 
19413 amit.gupta 4584 
  def process_getItemLocationAvailabilityCache(self, seqid, iprot, oprot):
4585 
    args = getItemLocationAvailabilityCache_args()
4586 
    args.read(iprot)
4587 
    iprot.readMessageEnd()
4588 
    result = getItemLocationAvailabilityCache_result()
4589 
    result.success = self._handler.getItemLocationAvailabilityCache(args.itemLocations)
4590 
    oprot.writeMessageBegin("getItemLocationAvailabilityCache", TMessageType.REPLY, seqid)
4591 
    result.write(oprot)
4592 
    oprot.writeMessageEnd()
4593 
    oprot.trans.flush()
19247 kshitij.so 4594 
 
19413 amit.gupta 4595 
  def process_getItemLocationAvailabilityCacheByItemId(self, seqid, iprot, oprot):
4596 
    args = getItemLocationAvailabilityCacheByItemId_args()
4597 
    args.read(iprot)
4598 
    iprot.readMessageEnd()
4599 
    result = getItemLocationAvailabilityCacheByItemId_result()
4600 
    result.success = self._handler.getItemLocationAvailabilityCacheByItemId(args.itemIds)
4601 
    oprot.writeMessageBegin("getItemLocationAvailabilityCacheByItemId", TMessageType.REPLY, seqid)
4602 
    result.write(oprot)
4603 
    oprot.writeMessageEnd()
4604 
    oprot.trans.flush()
4605 
 
4606 
  def process_getItemPincodeAvailability(self, seqid, iprot, oprot):
4607 
    args = getItemPincodeAvailability_args()
4608 
    args.read(iprot)
4609 
    iprot.readMessageEnd()
4610 
    result = getItemPincodeAvailability_result()
19416 amit.gupta 4611 
    result.success = self._handler.getItemPincodeAvailability(args.itempricing, args.pincode)
19413 amit.gupta 4612 
    oprot.writeMessageBegin("getItemPincodeAvailability", TMessageType.REPLY, seqid)
4613 
    result.write(oprot)
4614 
    oprot.writeMessageEnd()
4615 
    oprot.trans.flush()
4616 
 
4617 
 
5944 mandeep.dh 4618 
# HELPER FUNCTIONS AND STRUCTURES
4619 
 
4620 
class addWarehouse_args:
4621 
  """
4622 
  Attributes:
4623 
   - warehouse
4624 
  """
4625 
 
4626 
  thrift_spec = (
4627 
    None, # 0
4628 
    (1, TType.STRUCT, 'warehouse', (Warehouse, Warehouse.thrift_spec), None, ), # 1
4629 
  )
4630 
 
4631 
  def __init__(self, warehouse=None,):
4632 
    self.warehouse = warehouse
4633 
 
4634 
  def read(self, iprot):
4635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4637 
      return
4638 
    iprot.readStructBegin()
4639 
    while True:
4640 
      (fname, ftype, fid) = iprot.readFieldBegin()
4641 
      if ftype == TType.STOP:
4642 
        break
4643 
      if fid == 1:
4644 
        if ftype == TType.STRUCT:
4645 
          self.warehouse = Warehouse()
4646 
          self.warehouse.read(iprot)
4647 
        else:
4648 
          iprot.skip(ftype)
4649 
      else:
4650 
        iprot.skip(ftype)
4651 
      iprot.readFieldEnd()
4652 
    iprot.readStructEnd()
4653 
 
4654 
  def write(self, oprot):
4655 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4656 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4657 
      return
4658 
    oprot.writeStructBegin('addWarehouse_args')
4659 
    if self.warehouse is not None:
4660 
      oprot.writeFieldBegin('warehouse', TType.STRUCT, 1)
4661 
      self.warehouse.write(oprot)
4662 
      oprot.writeFieldEnd()
4663 
    oprot.writeFieldStop()
4664 
    oprot.writeStructEnd()
4665 
 
4666 
  def validate(self):
4667 
    return
4668 
 
4669 
 
4670 
  def __repr__(self):
4671 
    L = ['%s=%r' % (key, value)
4672 
      for key, value in self.__dict__.iteritems()]
4673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4674 
 
4675 
  def __eq__(self, other):
4676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4677 
 
4678 
  def __ne__(self, other):
4679 
    return not (self == other)
4680 
 
4681 
class addWarehouse_result:
4682 
  """
4683 
  Attributes:
4684 
   - success
4685 
   - cex
4686 
  """
4687 
 
4688 
  thrift_spec = (
4689 
    (0, TType.I64, 'success', None, None, ), # 0
4690 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
4691 
  )
4692 
 
4693 
  def __init__(self, success=None, cex=None,):
4694 
    self.success = success
4695 
    self.cex = cex
4696 
 
4697 
  def read(self, iprot):
4698 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4699 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4700 
      return
4701 
    iprot.readStructBegin()
4702 
    while True:
4703 
      (fname, ftype, fid) = iprot.readFieldBegin()
4704 
      if ftype == TType.STOP:
4705 
        break
4706 
      if fid == 0:
4707 
        if ftype == TType.I64:
4708 
          self.success = iprot.readI64();
4709 
        else:
4710 
          iprot.skip(ftype)
4711 
      elif fid == 1:
4712 
        if ftype == TType.STRUCT:
4713 
          self.cex = InventoryServiceException()
4714 
          self.cex.read(iprot)
4715 
        else:
4716 
          iprot.skip(ftype)
4717 
      else:
4718 
        iprot.skip(ftype)
4719 
      iprot.readFieldEnd()
4720 
    iprot.readStructEnd()
4721 
 
4722 
  def write(self, oprot):
4723 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4724 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4725 
      return
4726 
    oprot.writeStructBegin('addWarehouse_result')
4727 
    if self.success is not None:
4728 
      oprot.writeFieldBegin('success', TType.I64, 0)
4729 
      oprot.writeI64(self.success)
4730 
      oprot.writeFieldEnd()
4731 
    if self.cex is not None:
4732 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
4733 
      self.cex.write(oprot)
4734 
      oprot.writeFieldEnd()
4735 
    oprot.writeFieldStop()
4736 
    oprot.writeStructEnd()
4737 
 
4738 
  def validate(self):
4739 
    return
4740 
 
4741 
 
4742 
  def __repr__(self):
4743 
    L = ['%s=%r' % (key, value)
4744 
      for key, value in self.__dict__.iteritems()]
4745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4746 
 
4747 
  def __eq__(self, other):
4748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4749 
 
4750 
  def __ne__(self, other):
4751 
    return not (self == other)
4752 
 
4753 
class addVendor_args:
4754 
  """
4755 
  Attributes:
4756 
   - vendor
4757 
  """
4758 
 
4759 
  thrift_spec = (
4760 
    None, # 0
4761 
    (1, TType.STRUCT, 'vendor', (Vendor, Vendor.thrift_spec), None, ), # 1
4762 
  )
4763 
 
4764 
  def __init__(self, vendor=None,):
4765 
    self.vendor = vendor
4766 
 
4767 
  def read(self, iprot):
4768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4770 
      return
4771 
    iprot.readStructBegin()
4772 
    while True:
4773 
      (fname, ftype, fid) = iprot.readFieldBegin()
4774 
      if ftype == TType.STOP:
4775 
        break
4776 
      if fid == 1:
4777 
        if ftype == TType.STRUCT:
4778 
          self.vendor = Vendor()
4779 
          self.vendor.read(iprot)
4780 
        else:
4781 
          iprot.skip(ftype)
4782 
      else:
4783 
        iprot.skip(ftype)
4784 
      iprot.readFieldEnd()
4785 
    iprot.readStructEnd()
4786 
 
4787 
  def write(self, oprot):
4788 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4789 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4790 
      return
4791 
    oprot.writeStructBegin('addVendor_args')
4792 
    if self.vendor is not None:
4793 
      oprot.writeFieldBegin('vendor', TType.STRUCT, 1)
4794 
      self.vendor.write(oprot)
4795 
      oprot.writeFieldEnd()
4796 
    oprot.writeFieldStop()
4797 
    oprot.writeStructEnd()
4798 
 
4799 
  def validate(self):
4800 
    return
4801 
 
4802 
 
4803 
  def __repr__(self):
4804 
    L = ['%s=%r' % (key, value)
4805 
      for key, value in self.__dict__.iteritems()]
4806 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4807 
 
4808 
  def __eq__(self, other):
4809 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4810 
 
4811 
  def __ne__(self, other):
4812 
    return not (self == other)
4813 
 
4814 
class addVendor_result:
4815 
  """
4816 
  Attributes:
4817 
   - success
4818 
   - cex
4819 
  """
4820 
 
4821 
  thrift_spec = (
4822 
    (0, TType.I64, 'success', None, None, ), # 0
4823 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
4824 
  )
4825 
 
4826 
  def __init__(self, success=None, cex=None,):
4827 
    self.success = success
4828 
    self.cex = cex
4829 
 
4830 
  def read(self, iprot):
4831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4833 
      return
4834 
    iprot.readStructBegin()
4835 
    while True:
4836 
      (fname, ftype, fid) = iprot.readFieldBegin()
4837 
      if ftype == TType.STOP:
4838 
        break
4839 
      if fid == 0:
4840 
        if ftype == TType.I64:
4841 
          self.success = iprot.readI64();
4842 
        else:
4843 
          iprot.skip(ftype)
4844 
      elif fid == 1:
4845 
        if ftype == TType.STRUCT:
4846 
          self.cex = InventoryServiceException()
4847 
          self.cex.read(iprot)
4848 
        else:
4849 
          iprot.skip(ftype)
4850 
      else:
4851 
        iprot.skip(ftype)
4852 
      iprot.readFieldEnd()
4853 
    iprot.readStructEnd()
4854 
 
4855 
  def write(self, oprot):
4856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4858 
      return
4859 
    oprot.writeStructBegin('addVendor_result')
4860 
    if self.success is not None:
4861 
      oprot.writeFieldBegin('success', TType.I64, 0)
4862 
      oprot.writeI64(self.success)
4863 
      oprot.writeFieldEnd()
4864 
    if self.cex is not None:
4865 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
4866 
      self.cex.write(oprot)
4867 
      oprot.writeFieldEnd()
4868 
    oprot.writeFieldStop()
4869 
    oprot.writeStructEnd()
4870 
 
4871 
  def validate(self):
4872 
    return
4873 
 
4874 
 
4875 
  def __repr__(self):
4876 
    L = ['%s=%r' % (key, value)
4877 
      for key, value in self.__dict__.iteritems()]
4878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4879 
 
4880 
  def __eq__(self, other):
4881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4882 
 
4883 
  def __ne__(self, other):
4884 
    return not (self == other)
4885 
 
4886 
class updateInventoryHistory_args:
4887 
  """
4888 
  Attributes:
4889 
   - warehouse_id
4890 
   - timestamp
4891 
   - availability
4892 
  """
4893 
 
4894 
  thrift_spec = (
4895 
    None, # 0
4896 
    (1, TType.I64, 'warehouse_id', None, None, ), # 1
4897 
    (2, TType.STRING, 'timestamp', None, None, ), # 2
4898 
    (3, TType.MAP, 'availability', (TType.STRING,None,TType.I64,None), None, ), # 3
4899 
  )
4900 
 
4901 
  def __init__(self, warehouse_id=None, timestamp=None, availability=None,):
4902 
    self.warehouse_id = warehouse_id
4903 
    self.timestamp = timestamp
4904 
    self.availability = availability
4905 
 
4906 
  def read(self, iprot):
4907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4909 
      return
4910 
    iprot.readStructBegin()
4911 
    while True:
4912 
      (fname, ftype, fid) = iprot.readFieldBegin()
4913 
      if ftype == TType.STOP:
4914 
        break
4915 
      if fid == 1:
4916 
        if ftype == TType.I64:
4917 
          self.warehouse_id = iprot.readI64();
4918 
        else:
4919 
          iprot.skip(ftype)
4920 
      elif fid == 2:
4921 
        if ftype == TType.STRING:
4922 
          self.timestamp = iprot.readString();
4923 
        else:
4924 
          iprot.skip(ftype)
4925 
      elif fid == 3:
4926 
        if ftype == TType.MAP:
4927 
          self.availability = {}
8182 amar.kumar 4928 
          (_ktype28, _vtype29, _size27 ) = iprot.readMapBegin()
4929 
          for _i31 in xrange(_size27):
4930 
            _key32 = iprot.readString();
4931 
            _val33 = iprot.readI64();
4932 
            self.availability[_key32] = _val33
5944 mandeep.dh 4933 
          iprot.readMapEnd()
4934 
        else:
4935 
          iprot.skip(ftype)
4936 
      else:
4937 
        iprot.skip(ftype)
4938 
      iprot.readFieldEnd()
4939 
    iprot.readStructEnd()
4940 
 
4941 
  def write(self, oprot):
4942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4944 
      return
4945 
    oprot.writeStructBegin('updateInventoryHistory_args')
4946 
    if self.warehouse_id is not None:
4947 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 1)
4948 
      oprot.writeI64(self.warehouse_id)
4949 
      oprot.writeFieldEnd()
4950 
    if self.timestamp is not None:
4951 
      oprot.writeFieldBegin('timestamp', TType.STRING, 2)
4952 
      oprot.writeString(self.timestamp)
4953 
      oprot.writeFieldEnd()
4954 
    if self.availability is not None:
4955 
      oprot.writeFieldBegin('availability', TType.MAP, 3)
4956 
      oprot.writeMapBegin(TType.STRING, TType.I64, len(self.availability))
8182 amar.kumar 4957 
      for kiter34,viter35 in self.availability.items():
4958 
        oprot.writeString(kiter34)
4959 
        oprot.writeI64(viter35)
5944 mandeep.dh 4960 
      oprot.writeMapEnd()
4961 
      oprot.writeFieldEnd()
4962 
    oprot.writeFieldStop()
4963 
    oprot.writeStructEnd()
4964 
 
4965 
  def validate(self):
4966 
    return
4967 
 
4968 
 
4969 
  def __repr__(self):
4970 
    L = ['%s=%r' % (key, value)
4971 
      for key, value in self.__dict__.iteritems()]
4972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4973 
 
4974 
  def __eq__(self, other):
4975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4976 
 
4977 
  def __ne__(self, other):
4978 
    return not (self == other)
4979 
 
4980 
class updateInventoryHistory_result:
4981 
  """
4982 
  Attributes:
4983 
   - cex
4984 
  """
4985 
 
4986 
  thrift_spec = (
4987 
    None, # 0
4988 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
4989 
  )
4990 
 
4991 
  def __init__(self, cex=None,):
4992 
    self.cex = cex
4993 
 
4994 
  def read(self, iprot):
4995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4997 
      return
4998 
    iprot.readStructBegin()
4999 
    while True:
5000 
      (fname, ftype, fid) = iprot.readFieldBegin()
5001 
      if ftype == TType.STOP:
5002 
        break
5003 
      if fid == 1:
5004 
        if ftype == TType.STRUCT:
5005 
          self.cex = InventoryServiceException()
5006 
          self.cex.read(iprot)
5007 
        else:
5008 
          iprot.skip(ftype)
5009 
      else:
5010 
        iprot.skip(ftype)
5011 
      iprot.readFieldEnd()
5012 
    iprot.readStructEnd()
5013 
 
5014 
  def write(self, oprot):
5015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5017 
      return
5018 
    oprot.writeStructBegin('updateInventoryHistory_result')
5019 
    if self.cex is not None:
5020 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5021 
      self.cex.write(oprot)
5022 
      oprot.writeFieldEnd()
5023 
    oprot.writeFieldStop()
5024 
    oprot.writeStructEnd()
5025 
 
5026 
  def validate(self):
5027 
    return
5028 
 
5029 
 
5030 
  def __repr__(self):
5031 
    L = ['%s=%r' % (key, value)
5032 
      for key, value in self.__dict__.iteritems()]
5033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5034 
 
5035 
  def __eq__(self, other):
5036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5037 
 
5038 
  def __ne__(self, other):
5039 
    return not (self == other)
5040 
 
5041 
class updateInventory_args:
5042 
  """
5043 
  Attributes:
5044 
   - warehouse_id
5045 
   - timestamp
5046 
   - availability
5047 
  """
5048 
 
5049 
  thrift_spec = (
5050 
    None, # 0
5051 
    (1, TType.I64, 'warehouse_id', None, None, ), # 1
5052 
    (2, TType.STRING, 'timestamp', None, None, ), # 2
5053 
    (3, TType.MAP, 'availability', (TType.STRING,None,TType.I64,None), None, ), # 3
5054 
  )
5055 
 
5056 
  def __init__(self, warehouse_id=None, timestamp=None, availability=None,):
5057 
    self.warehouse_id = warehouse_id
5058 
    self.timestamp = timestamp
5059 
    self.availability = availability
5060 
 
5061 
  def read(self, iprot):
5062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5064 
      return
5065 
    iprot.readStructBegin()
5066 
    while True:
5067 
      (fname, ftype, fid) = iprot.readFieldBegin()
5068 
      if ftype == TType.STOP:
5069 
        break
5070 
      if fid == 1:
5071 
        if ftype == TType.I64:
5072 
          self.warehouse_id = iprot.readI64();
5073 
        else:
5074 
          iprot.skip(ftype)
5075 
      elif fid == 2:
5076 
        if ftype == TType.STRING:
5077 
          self.timestamp = iprot.readString();
5078 
        else:
5079 
          iprot.skip(ftype)
5080 
      elif fid == 3:
5081 
        if ftype == TType.MAP:
5082 
          self.availability = {}
8182 amar.kumar 5083 
          (_ktype37, _vtype38, _size36 ) = iprot.readMapBegin()
5084 
          for _i40 in xrange(_size36):
5085 
            _key41 = iprot.readString();
5086 
            _val42 = iprot.readI64();
5087 
            self.availability[_key41] = _val42
5944 mandeep.dh 5088 
          iprot.readMapEnd()
5089 
        else:
5090 
          iprot.skip(ftype)
5091 
      else:
5092 
        iprot.skip(ftype)
5093 
      iprot.readFieldEnd()
5094 
    iprot.readStructEnd()
5095 
 
5096 
  def write(self, oprot):
5097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5099 
      return
5100 
    oprot.writeStructBegin('updateInventory_args')
5101 
    if self.warehouse_id is not None:
5102 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 1)
5103 
      oprot.writeI64(self.warehouse_id)
5104 
      oprot.writeFieldEnd()
5105 
    if self.timestamp is not None:
5106 
      oprot.writeFieldBegin('timestamp', TType.STRING, 2)
5107 
      oprot.writeString(self.timestamp)
5108 
      oprot.writeFieldEnd()
5109 
    if self.availability is not None:
5110 
      oprot.writeFieldBegin('availability', TType.MAP, 3)
5111 
      oprot.writeMapBegin(TType.STRING, TType.I64, len(self.availability))
8182 amar.kumar 5112 
      for kiter43,viter44 in self.availability.items():
5113 
        oprot.writeString(kiter43)
5114 
        oprot.writeI64(viter44)
5944 mandeep.dh 5115 
      oprot.writeMapEnd()
5116 
      oprot.writeFieldEnd()
5117 
    oprot.writeFieldStop()
5118 
    oprot.writeStructEnd()
5119 
 
5120 
  def validate(self):
5121 
    return
5122 
 
5123 
 
5124 
  def __repr__(self):
5125 
    L = ['%s=%r' % (key, value)
5126 
      for key, value in self.__dict__.iteritems()]
5127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5128 
 
5129 
  def __eq__(self, other):
5130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5131 
 
5132 
  def __ne__(self, other):
5133 
    return not (self == other)
5134 
 
5135 
class updateInventory_result:
5136 
  """
5137 
  Attributes:
5138 
   - cex
5139 
  """
5140 
 
5141 
  thrift_spec = (
5142 
    None, # 0
5143 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
5144 
  )
5145 
 
5146 
  def __init__(self, cex=None,):
5147 
    self.cex = cex
5148 
 
5149 
  def read(self, iprot):
5150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5152 
      return
5153 
    iprot.readStructBegin()
5154 
    while True:
5155 
      (fname, ftype, fid) = iprot.readFieldBegin()
5156 
      if ftype == TType.STOP:
5157 
        break
5158 
      if fid == 1:
5159 
        if ftype == TType.STRUCT:
5160 
          self.cex = InventoryServiceException()
5161 
          self.cex.read(iprot)
5162 
        else:
5163 
          iprot.skip(ftype)
5164 
      else:
5165 
        iprot.skip(ftype)
5166 
      iprot.readFieldEnd()
5167 
    iprot.readStructEnd()
5168 
 
5169 
  def write(self, oprot):
5170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5172 
      return
5173 
    oprot.writeStructBegin('updateInventory_result')
5174 
    if self.cex is not None:
5175 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5176 
      self.cex.write(oprot)
5177 
      oprot.writeFieldEnd()
5178 
    oprot.writeFieldStop()
5179 
    oprot.writeStructEnd()
5180 
 
5181 
  def validate(self):
5182 
    return
5183 
 
5184 
 
5185 
  def __repr__(self):
5186 
    L = ['%s=%r' % (key, value)
5187 
      for key, value in self.__dict__.iteritems()]
5188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5189 
 
5190 
  def __eq__(self, other):
5191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5192 
 
5193 
  def __ne__(self, other):
5194 
    return not (self == other)
5195 
 
5196 
class addInventory_args:
5197 
  """
5198 
  Attributes:
5199 
   - itemId
5200 
   - warehouseId
5201 
   - quantity
5202 
  """
5203 
 
5204 
  thrift_spec = (
5205 
    None, # 0
5206 
    (1, TType.I64, 'itemId', None, None, ), # 1
5207 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
5208 
    (3, TType.I64, 'quantity', None, None, ), # 3
5209 
  )
5210 
 
5211 
  def __init__(self, itemId=None, warehouseId=None, quantity=None,):
5212 
    self.itemId = itemId
5213 
    self.warehouseId = warehouseId
5214 
    self.quantity = quantity
5215 
 
5216 
  def read(self, iprot):
5217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5219 
      return
5220 
    iprot.readStructBegin()
5221 
    while True:
5222 
      (fname, ftype, fid) = iprot.readFieldBegin()
5223 
      if ftype == TType.STOP:
5224 
        break
5225 
      if fid == 1:
5226 
        if ftype == TType.I64:
5227 
          self.itemId = iprot.readI64();
5228 
        else:
5229 
          iprot.skip(ftype)
5230 
      elif fid == 2:
5231 
        if ftype == TType.I64:
5232 
          self.warehouseId = iprot.readI64();
5233 
        else:
5234 
          iprot.skip(ftype)
5235 
      elif fid == 3:
5236 
        if ftype == TType.I64:
5237 
          self.quantity = iprot.readI64();
5238 
        else:
5239 
          iprot.skip(ftype)
5240 
      else:
5241 
        iprot.skip(ftype)
5242 
      iprot.readFieldEnd()
5243 
    iprot.readStructEnd()
5244 
 
5245 
  def write(self, oprot):
5246 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5247 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5248 
      return
5249 
    oprot.writeStructBegin('addInventory_args')
5250 
    if self.itemId is not None:
5251 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5252 
      oprot.writeI64(self.itemId)
5253 
      oprot.writeFieldEnd()
5254 
    if self.warehouseId is not None:
5255 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
5256 
      oprot.writeI64(self.warehouseId)
5257 
      oprot.writeFieldEnd()
5258 
    if self.quantity is not None:
5259 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
5260 
      oprot.writeI64(self.quantity)
5261 
      oprot.writeFieldEnd()
5262 
    oprot.writeFieldStop()
5263 
    oprot.writeStructEnd()
5264 
 
5265 
  def validate(self):
5266 
    return
5267 
 
5268 
 
5269 
  def __repr__(self):
5270 
    L = ['%s=%r' % (key, value)
5271 
      for key, value in self.__dict__.iteritems()]
5272 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5273 
 
5274 
  def __eq__(self, other):
5275 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5276 
 
5277 
  def __ne__(self, other):
5278 
    return not (self == other)
5279 
 
5280 
class addInventory_result:
5281 
  """
5282 
  Attributes:
5283 
   - cex
5284 
  """
5285 
 
5286 
  thrift_spec = (
5287 
    None, # 0
5288 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
5289 
  )
5290 
 
5291 
  def __init__(self, cex=None,):
5292 
    self.cex = cex
5293 
 
5294 
  def read(self, iprot):
5295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5297 
      return
5298 
    iprot.readStructBegin()
5299 
    while True:
5300 
      (fname, ftype, fid) = iprot.readFieldBegin()
5301 
      if ftype == TType.STOP:
5302 
        break
5303 
      if fid == 1:
5304 
        if ftype == TType.STRUCT:
5305 
          self.cex = InventoryServiceException()
5306 
          self.cex.read(iprot)
5307 
        else:
5308 
          iprot.skip(ftype)
5309 
      else:
5310 
        iprot.skip(ftype)
5311 
      iprot.readFieldEnd()
5312 
    iprot.readStructEnd()
5313 
 
5314 
  def write(self, oprot):
5315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5317 
      return
5318 
    oprot.writeStructBegin('addInventory_result')
5319 
    if self.cex is not None:
5320 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5321 
      self.cex.write(oprot)
5322 
      oprot.writeFieldEnd()
5323 
    oprot.writeFieldStop()
5324 
    oprot.writeStructEnd()
5325 
 
5326 
  def validate(self):
5327 
    return
5328 
 
5329 
 
5330 
  def __repr__(self):
5331 
    L = ['%s=%r' % (key, value)
5332 
      for key, value in self.__dict__.iteritems()]
5333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5334 
 
5335 
  def __eq__(self, other):
5336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5337 
 
5338 
  def __ne__(self, other):
5339 
    return not (self == other)
5340 
 
5341 
class retireWarehouse_args:
5342 
  """
5343 
  Attributes:
5344 
   - warehouse_id
5345 
  """
5346 
 
5347 
  thrift_spec = (
5348 
    None, # 0
5349 
    (1, TType.I64, 'warehouse_id', None, None, ), # 1
5350 
  )
5351 
 
5352 
  def __init__(self, warehouse_id=None,):
5353 
    self.warehouse_id = warehouse_id
5354 
 
5355 
  def read(self, iprot):
5356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5358 
      return
5359 
    iprot.readStructBegin()
5360 
    while True:
5361 
      (fname, ftype, fid) = iprot.readFieldBegin()
5362 
      if ftype == TType.STOP:
5363 
        break
5364 
      if fid == 1:
5365 
        if ftype == TType.I64:
5366 
          self.warehouse_id = iprot.readI64();
5367 
        else:
5368 
          iprot.skip(ftype)
5369 
      else:
5370 
        iprot.skip(ftype)
5371 
      iprot.readFieldEnd()
5372 
    iprot.readStructEnd()
5373 
 
5374 
  def write(self, oprot):
5375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5377 
      return
5378 
    oprot.writeStructBegin('retireWarehouse_args')
5379 
    if self.warehouse_id is not None:
5380 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 1)
5381 
      oprot.writeI64(self.warehouse_id)
5382 
      oprot.writeFieldEnd()
5383 
    oprot.writeFieldStop()
5384 
    oprot.writeStructEnd()
5385 
 
5386 
  def validate(self):
5387 
    return
5388 
 
5389 
 
5390 
  def __repr__(self):
5391 
    L = ['%s=%r' % (key, value)
5392 
      for key, value in self.__dict__.iteritems()]
5393 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5394 
 
5395 
  def __eq__(self, other):
5396 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5397 
 
5398 
  def __ne__(self, other):
5399 
    return not (self == other)
5400 
 
5401 
class retireWarehouse_result:
5402 
  """
5403 
  Attributes:
5404 
   - cex
5405 
  """
5406 
 
5407 
  thrift_spec = (
5408 
    None, # 0
5409 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
5410 
  )
5411 
 
5412 
  def __init__(self, cex=None,):
5413 
    self.cex = cex
5414 
 
5415 
  def read(self, iprot):
5416 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5417 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5418 
      return
5419 
    iprot.readStructBegin()
5420 
    while True:
5421 
      (fname, ftype, fid) = iprot.readFieldBegin()
5422 
      if ftype == TType.STOP:
5423 
        break
5424 
      if fid == 1:
5425 
        if ftype == TType.STRUCT:
5426 
          self.cex = InventoryServiceException()
5427 
          self.cex.read(iprot)
5428 
        else:
5429 
          iprot.skip(ftype)
5430 
      else:
5431 
        iprot.skip(ftype)
5432 
      iprot.readFieldEnd()
5433 
    iprot.readStructEnd()
5434 
 
5435 
  def write(self, oprot):
5436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5438 
      return
5439 
    oprot.writeStructBegin('retireWarehouse_result')
5440 
    if self.cex is not None:
5441 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5442 
      self.cex.write(oprot)
5443 
      oprot.writeFieldEnd()
5444 
    oprot.writeFieldStop()
5445 
    oprot.writeStructEnd()
5446 
 
5447 
  def validate(self):
5448 
    return
5449 
 
5450 
 
5451 
  def __repr__(self):
5452 
    L = ['%s=%r' % (key, value)
5453 
      for key, value in self.__dict__.iteritems()]
5454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5455 
 
5456 
  def __eq__(self, other):
5457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5458 
 
5459 
  def __ne__(self, other):
5460 
    return not (self == other)
5461 
 
5462 
class getItemInventoryByItemId_args:
5463 
  """
5464 
  Attributes:
5465 
   - item_id
5466 
  """
5467 
 
5468 
  thrift_spec = (
5469 
    None, # 0
5470 
    (1, TType.I64, 'item_id', None, None, ), # 1
5471 
  )
5472 
 
5473 
  def __init__(self, item_id=None,):
5474 
    self.item_id = item_id
5475 
 
5476 
  def read(self, iprot):
5477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5479 
      return
5480 
    iprot.readStructBegin()
5481 
    while True:
5482 
      (fname, ftype, fid) = iprot.readFieldBegin()
5483 
      if ftype == TType.STOP:
5484 
        break
5485 
      if fid == 1:
5486 
        if ftype == TType.I64:
5487 
          self.item_id = iprot.readI64();
5488 
        else:
5489 
          iprot.skip(ftype)
5490 
      else:
5491 
        iprot.skip(ftype)
5492 
      iprot.readFieldEnd()
5493 
    iprot.readStructEnd()
5494 
 
5495 
  def write(self, oprot):
5496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5498 
      return
5499 
    oprot.writeStructBegin('getItemInventoryByItemId_args')
5500 
    if self.item_id is not None:
5501 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
5502 
      oprot.writeI64(self.item_id)
5503 
      oprot.writeFieldEnd()
5504 
    oprot.writeFieldStop()
5505 
    oprot.writeStructEnd()
5506 
 
5507 
  def validate(self):
5508 
    return
5509 
 
5510 
 
5511 
  def __repr__(self):
5512 
    L = ['%s=%r' % (key, value)
5513 
      for key, value in self.__dict__.iteritems()]
5514 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5515 
 
5516 
  def __eq__(self, other):
5517 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5518 
 
5519 
  def __ne__(self, other):
5520 
    return not (self == other)
5521 
 
5522 
class getItemInventoryByItemId_result:
5523 
  """
5524 
  Attributes:
5525 
   - success
5526 
   - cex
5527 
  """
5528 
 
5529 
  thrift_spec = (
5530 
    (0, TType.STRUCT, 'success', (ItemInventory, ItemInventory.thrift_spec), None, ), # 0
5531 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
5532 
  )
5533 
 
5534 
  def __init__(self, success=None, cex=None,):
5535 
    self.success = success
5536 
    self.cex = cex
5537 
 
5538 
  def read(self, iprot):
5539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5541 
      return
5542 
    iprot.readStructBegin()
5543 
    while True:
5544 
      (fname, ftype, fid) = iprot.readFieldBegin()
5545 
      if ftype == TType.STOP:
5546 
        break
5547 
      if fid == 0:
5548 
        if ftype == TType.STRUCT:
5549 
          self.success = ItemInventory()
5550 
          self.success.read(iprot)
5551 
        else:
5552 
          iprot.skip(ftype)
5553 
      elif fid == 1:
5554 
        if ftype == TType.STRUCT:
5555 
          self.cex = InventoryServiceException()
5556 
          self.cex.read(iprot)
5557 
        else:
5558 
          iprot.skip(ftype)
5559 
      else:
5560 
        iprot.skip(ftype)
5561 
      iprot.readFieldEnd()
5562 
    iprot.readStructEnd()
5563 
 
5564 
  def write(self, oprot):
5565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5567 
      return
5568 
    oprot.writeStructBegin('getItemInventoryByItemId_result')
5569 
    if self.success is not None:
5570 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5571 
      self.success.write(oprot)
5572 
      oprot.writeFieldEnd()
5573 
    if self.cex is not None:
5574 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5575 
      self.cex.write(oprot)
5576 
      oprot.writeFieldEnd()
5577 
    oprot.writeFieldStop()
5578 
    oprot.writeStructEnd()
5579 
 
5580 
  def validate(self):
5581 
    return
5582 
 
5583 
 
5584 
  def __repr__(self):
5585 
    L = ['%s=%r' % (key, value)
5586 
      for key, value in self.__dict__.iteritems()]
5587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5588 
 
5589 
  def __eq__(self, other):
5590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5591 
 
5592 
  def __ne__(self, other):
5593 
    return not (self == other)
5594 
 
5595 
class getItemAvailibilityAtWarehouse_args:
5596 
  """
5597 
  Attributes:
5598 
   - warehouse_id
5599 
   - item_id
5600 
  """
5601 
 
5602 
  thrift_spec = (
5603 
    None, # 0
5604 
    (1, TType.I64, 'warehouse_id', None, None, ), # 1
5605 
    (2, TType.I64, 'item_id', None, None, ), # 2
5606 
  )
5607 
 
5608 
  def __init__(self, warehouse_id=None, item_id=None,):
5609 
    self.warehouse_id = warehouse_id
5610 
    self.item_id = item_id
5611 
 
5612 
  def read(self, iprot):
5613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5615 
      return
5616 
    iprot.readStructBegin()
5617 
    while True:
5618 
      (fname, ftype, fid) = iprot.readFieldBegin()
5619 
      if ftype == TType.STOP:
5620 
        break
5621 
      if fid == 1:
5622 
        if ftype == TType.I64:
5623 
          self.warehouse_id = iprot.readI64();
5624 
        else:
5625 
          iprot.skip(ftype)
5626 
      elif fid == 2:
5627 
        if ftype == TType.I64:
5628 
          self.item_id = iprot.readI64();
5629 
        else:
5630 
          iprot.skip(ftype)
5631 
      else:
5632 
        iprot.skip(ftype)
5633 
      iprot.readFieldEnd()
5634 
    iprot.readStructEnd()
5635 
 
5636 
  def write(self, oprot):
5637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5639 
      return
5640 
    oprot.writeStructBegin('getItemAvailibilityAtWarehouse_args')
5641 
    if self.warehouse_id is not None:
5642 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 1)
5643 
      oprot.writeI64(self.warehouse_id)
5644 
      oprot.writeFieldEnd()
5645 
    if self.item_id is not None:
5646 
      oprot.writeFieldBegin('item_id', TType.I64, 2)
5647 
      oprot.writeI64(self.item_id)
5648 
      oprot.writeFieldEnd()
5649 
    oprot.writeFieldStop()
5650 
    oprot.writeStructEnd()
5651 
 
5652 
  def validate(self):
5653 
    return
5654 
 
5655 
 
5656 
  def __repr__(self):
5657 
    L = ['%s=%r' % (key, value)
5658 
      for key, value in self.__dict__.iteritems()]
5659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5660 
 
5661 
  def __eq__(self, other):
5662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5663 
 
5664 
  def __ne__(self, other):
5665 
    return not (self == other)
5666 
 
5667 
class getItemAvailibilityAtWarehouse_result:
5668 
  """
5669 
  Attributes:
5670 
   - success
5671 
   - cex
5672 
  """
5673 
 
5674 
  thrift_spec = (
5675 
    (0, TType.I64, 'success', None, None, ), # 0
5676 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
5677 
  )
5678 
 
5679 
  def __init__(self, success=None, cex=None,):
5680 
    self.success = success
5681 
    self.cex = cex
5682 
 
5683 
  def read(self, iprot):
5684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5686 
      return
5687 
    iprot.readStructBegin()
5688 
    while True:
5689 
      (fname, ftype, fid) = iprot.readFieldBegin()
5690 
      if ftype == TType.STOP:
5691 
        break
5692 
      if fid == 0:
5693 
        if ftype == TType.I64:
5694 
          self.success = iprot.readI64();
5695 
        else:
5696 
          iprot.skip(ftype)
5697 
      elif fid == 1:
5698 
        if ftype == TType.STRUCT:
5699 
          self.cex = InventoryServiceException()
5700 
          self.cex.read(iprot)
5701 
        else:
5702 
          iprot.skip(ftype)
5703 
      else:
5704 
        iprot.skip(ftype)
5705 
      iprot.readFieldEnd()
5706 
    iprot.readStructEnd()
5707 
 
5708 
  def write(self, oprot):
5709 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5710 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5711 
      return
5712 
    oprot.writeStructBegin('getItemAvailibilityAtWarehouse_result')
5713 
    if self.success is not None:
5714 
      oprot.writeFieldBegin('success', TType.I64, 0)
5715 
      oprot.writeI64(self.success)
5716 
      oprot.writeFieldEnd()
5717 
    if self.cex is not None:
5718 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5719 
      self.cex.write(oprot)
5720 
      oprot.writeFieldEnd()
5721 
    oprot.writeFieldStop()
5722 
    oprot.writeStructEnd()
5723 
 
5724 
  def validate(self):
5725 
    return
5726 
 
5727 
 
5728 
  def __repr__(self):
5729 
    L = ['%s=%r' % (key, value)
5730 
      for key, value in self.__dict__.iteritems()]
5731 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5732 
 
5733 
  def __eq__(self, other):
5734 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5735 
 
5736 
  def __ne__(self, other):
5737 
    return not (self == other)
5738 
 
5739 
class getItemAvailabilityAtLocation_args:
5740 
  """
5741 
  Attributes:
5742 
   - itemId
5978 rajveer 5743 
   - sourceId
5944 mandeep.dh 5744 
  """
5745 
 
5746 
  thrift_spec = (
5747 
    None, # 0
5748 
    (1, TType.I64, 'itemId', None, None, ), # 1
5978 rajveer 5749 
    (2, TType.I64, 'sourceId', None, None, ), # 2
5944 mandeep.dh 5750 
  )
5751 
 
5978 rajveer 5752 
  def __init__(self, itemId=None, sourceId=None,):
5944 mandeep.dh 5753 
    self.itemId = itemId
5978 rajveer 5754 
    self.sourceId = sourceId
5944 mandeep.dh 5755 
 
5756 
  def read(self, iprot):
5757 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5758 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5759 
      return
5760 
    iprot.readStructBegin()
5761 
    while True:
5762 
      (fname, ftype, fid) = iprot.readFieldBegin()
5763 
      if ftype == TType.STOP:
5764 
        break
5765 
      if fid == 1:
5766 
        if ftype == TType.I64:
5767 
          self.itemId = iprot.readI64();
5768 
        else:
5769 
          iprot.skip(ftype)
5978 rajveer 5770 
      elif fid == 2:
5771 
        if ftype == TType.I64:
5772 
          self.sourceId = iprot.readI64();
5773 
        else:
5774 
          iprot.skip(ftype)
5944 mandeep.dh 5775 
      else:
5776 
        iprot.skip(ftype)
5777 
      iprot.readFieldEnd()
5778 
    iprot.readStructEnd()
5779 
 
5780 
  def write(self, oprot):
5781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5783 
      return
5784 
    oprot.writeStructBegin('getItemAvailabilityAtLocation_args')
5785 
    if self.itemId is not None:
5786 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5787 
      oprot.writeI64(self.itemId)
5788 
      oprot.writeFieldEnd()
5978 rajveer 5789 
    if self.sourceId is not None:
5790 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
5791 
      oprot.writeI64(self.sourceId)
5792 
      oprot.writeFieldEnd()
5944 mandeep.dh 5793 
    oprot.writeFieldStop()
5794 
    oprot.writeStructEnd()
5795 
 
5796 
  def validate(self):
5797 
    return
5798 
 
5799 
 
5800 
  def __repr__(self):
5801 
    L = ['%s=%r' % (key, value)
5802 
      for key, value in self.__dict__.iteritems()]
5803 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5804 
 
5805 
  def __eq__(self, other):
5806 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5807 
 
5808 
  def __ne__(self, other):
5809 
    return not (self == other)
5810 
 
5811 
class getItemAvailabilityAtLocation_result:
5812 
  """
5813 
  Attributes:
5814 
   - success
5815 
   - isex
5816 
  """
5817 
 
5818 
  thrift_spec = (
5819 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
5820 
    (1, TType.STRUCT, 'isex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
5821 
  )
5822 
 
5823 
  def __init__(self, success=None, isex=None,):
5824 
    self.success = success
5825 
    self.isex = isex
5826 
 
5827 
  def read(self, iprot):
5828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5830 
      return
5831 
    iprot.readStructBegin()
5832 
    while True:
5833 
      (fname, ftype, fid) = iprot.readFieldBegin()
5834 
      if ftype == TType.STOP:
5835 
        break
5836 
      if fid == 0:
5837 
        if ftype == TType.LIST:
5838 
          self.success = []
8182 amar.kumar 5839 
          (_etype48, _size45) = iprot.readListBegin()
5840 
          for _i49 in xrange(_size45):
5841 
            _elem50 = iprot.readI64();
5842 
            self.success.append(_elem50)
5944 mandeep.dh 5843 
          iprot.readListEnd()
5844 
        else:
5845 
          iprot.skip(ftype)
5846 
      elif fid == 1:
5847 
        if ftype == TType.STRUCT:
5848 
          self.isex = InventoryServiceException()
5849 
          self.isex.read(iprot)
5850 
        else:
5851 
          iprot.skip(ftype)
5852 
      else:
5853 
        iprot.skip(ftype)
5854 
      iprot.readFieldEnd()
5855 
    iprot.readStructEnd()
5856 
 
5857 
  def write(self, oprot):
5858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5860 
      return
5861 
    oprot.writeStructBegin('getItemAvailabilityAtLocation_result')
5862 
    if self.success is not None:
5863 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5864 
      oprot.writeListBegin(TType.I64, len(self.success))
8182 amar.kumar 5865 
      for iter51 in self.success:
5866 
        oprot.writeI64(iter51)
5944 mandeep.dh 5867 
      oprot.writeListEnd()
5868 
      oprot.writeFieldEnd()
5869 
    if self.isex is not None:
5870 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
5871 
      self.isex.write(oprot)
5872 
      oprot.writeFieldEnd()
5873 
    oprot.writeFieldStop()
5874 
    oprot.writeStructEnd()
5875 
 
5876 
  def validate(self):
5877 
    return
5878 
 
5879 
 
5880 
  def __repr__(self):
5881 
    L = ['%s=%r' % (key, value)
5882 
      for key, value in self.__dict__.iteritems()]
5883 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5884 
 
5885 
  def __eq__(self, other):
5886 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5887 
 
5888 
  def __ne__(self, other):
5889 
    return not (self == other)
5890 
 
5891 
class getAllWarehouses_args:
5892 
  """
5893 
  Attributes:
5894 
   - isActive
5895 
  """
5896 
 
5897 
  thrift_spec = (
5898 
    None, # 0
5899 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
5900 
  )
5901 
 
5902 
  def __init__(self, isActive=None,):
5903 
    self.isActive = isActive
5904 
 
5905 
  def read(self, iprot):
5906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5908 
      return
5909 
    iprot.readStructBegin()
5910 
    while True:
5911 
      (fname, ftype, fid) = iprot.readFieldBegin()
5912 
      if ftype == TType.STOP:
5913 
        break
5914 
      if fid == 1:
5915 
        if ftype == TType.BOOL:
5916 
          self.isActive = iprot.readBool();
5917 
        else:
5918 
          iprot.skip(ftype)
5919 
      else:
5920 
        iprot.skip(ftype)
5921 
      iprot.readFieldEnd()
5922 
    iprot.readStructEnd()
5923 
 
5924 
  def write(self, oprot):
5925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5927 
      return
5928 
    oprot.writeStructBegin('getAllWarehouses_args')
5929 
    if self.isActive is not None:
5930 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
5931 
      oprot.writeBool(self.isActive)
5932 
      oprot.writeFieldEnd()
5933 
    oprot.writeFieldStop()
5934 
    oprot.writeStructEnd()
5935 
 
5936 
  def validate(self):
5937 
    return
5938 
 
5939 
 
5940 
  def __repr__(self):
5941 
    L = ['%s=%r' % (key, value)
5942 
      for key, value in self.__dict__.iteritems()]
5943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5944 
 
5945 
  def __eq__(self, other):
5946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5947 
 
5948 
  def __ne__(self, other):
5949 
    return not (self == other)
5950 
 
5951 
class getAllWarehouses_result:
5952 
  """
5953 
  Attributes:
5954 
   - success
5955 
   - cex
5956 
  """
5957 
 
5958 
  thrift_spec = (
5959 
    (0, TType.LIST, 'success', (TType.STRUCT,(Warehouse, Warehouse.thrift_spec)), None, ), # 0
5960 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
5961 
  )
5962 
 
5963 
  def __init__(self, success=None, cex=None,):
5964 
    self.success = success
5965 
    self.cex = cex
5966 
 
5967 
  def read(self, iprot):
5968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5970 
      return
5971 
    iprot.readStructBegin()
5972 
    while True:
5973 
      (fname, ftype, fid) = iprot.readFieldBegin()
5974 
      if ftype == TType.STOP:
5975 
        break
5976 
      if fid == 0:
5977 
        if ftype == TType.LIST:
5978 
          self.success = []
8182 amar.kumar 5979 
          (_etype55, _size52) = iprot.readListBegin()
5980 
          for _i56 in xrange(_size52):
5981 
            _elem57 = Warehouse()
5982 
            _elem57.read(iprot)
5983 
            self.success.append(_elem57)
5944 mandeep.dh 5984 
          iprot.readListEnd()
5985 
        else:
5986 
          iprot.skip(ftype)
5987 
      elif fid == 1:
5988 
        if ftype == TType.STRUCT:
5989 
          self.cex = InventoryServiceException()
5990 
          self.cex.read(iprot)
5991 
        else:
5992 
          iprot.skip(ftype)
5993 
      else:
5994 
        iprot.skip(ftype)
5995 
      iprot.readFieldEnd()
5996 
    iprot.readStructEnd()
5997 
 
5998 
  def write(self, oprot):
5999 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6000 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6001 
      return
6002 
    oprot.writeStructBegin('getAllWarehouses_result')
6003 
    if self.success is not None:
6004 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6005 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 6006 
      for iter58 in self.success:
6007 
        iter58.write(oprot)
5944 mandeep.dh 6008 
      oprot.writeListEnd()
6009 
      oprot.writeFieldEnd()
6010 
    if self.cex is not None:
6011 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6012 
      self.cex.write(oprot)
6013 
      oprot.writeFieldEnd()
6014 
    oprot.writeFieldStop()
6015 
    oprot.writeStructEnd()
6016 
 
6017 
  def validate(self):
6018 
    return
6019 
 
6020 
 
6021 
  def __repr__(self):
6022 
    L = ['%s=%r' % (key, value)
6023 
      for key, value in self.__dict__.iteritems()]
6024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6025 
 
6026 
  def __eq__(self, other):
6027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6028 
 
6029 
  def __ne__(self, other):
6030 
    return not (self == other)
6031 
 
6032 
class getWarehouse_args:
6033 
  """
6034 
  Attributes:
6035 
   - warehouse_id
6036 
  """
6037 
 
6038 
  thrift_spec = (
6039 
    None, # 0
6040 
    (1, TType.I64, 'warehouse_id', None, None, ), # 1
6041 
  )
6042 
 
6043 
  def __init__(self, warehouse_id=None,):
6044 
    self.warehouse_id = warehouse_id
6045 
 
6046 
  def read(self, iprot):
6047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6049 
      return
6050 
    iprot.readStructBegin()
6051 
    while True:
6052 
      (fname, ftype, fid) = iprot.readFieldBegin()
6053 
      if ftype == TType.STOP:
6054 
        break
6055 
      if fid == 1:
6056 
        if ftype == TType.I64:
6057 
          self.warehouse_id = iprot.readI64();
6058 
        else:
6059 
          iprot.skip(ftype)
6060 
      else:
6061 
        iprot.skip(ftype)
6062 
      iprot.readFieldEnd()
6063 
    iprot.readStructEnd()
6064 
 
6065 
  def write(self, oprot):
6066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6068 
      return
6069 
    oprot.writeStructBegin('getWarehouse_args')
6070 
    if self.warehouse_id is not None:
6071 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 1)
6072 
      oprot.writeI64(self.warehouse_id)
6073 
      oprot.writeFieldEnd()
6074 
    oprot.writeFieldStop()
6075 
    oprot.writeStructEnd()
6076 
 
6077 
  def validate(self):
6078 
    return
6079 
 
6080 
 
6081 
  def __repr__(self):
6082 
    L = ['%s=%r' % (key, value)
6083 
      for key, value in self.__dict__.iteritems()]
6084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6085 
 
6086 
  def __eq__(self, other):
6087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6088 
 
6089 
  def __ne__(self, other):
6090 
    return not (self == other)
6091 
 
6092 
class getWarehouse_result:
6093 
  """
6094 
  Attributes:
6095 
   - success
6096 
   - cex
6097 
  """
6098 
 
6099 
  thrift_spec = (
6100 
    (0, TType.STRUCT, 'success', (Warehouse, Warehouse.thrift_spec), None, ), # 0
6101 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
6102 
  )
6103 
 
6104 
  def __init__(self, success=None, cex=None,):
6105 
    self.success = success
6106 
    self.cex = cex
6107 
 
6108 
  def read(self, iprot):
6109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6111 
      return
6112 
    iprot.readStructBegin()
6113 
    while True:
6114 
      (fname, ftype, fid) = iprot.readFieldBegin()
6115 
      if ftype == TType.STOP:
6116 
        break
6117 
      if fid == 0:
6118 
        if ftype == TType.STRUCT:
6119 
          self.success = Warehouse()
6120 
          self.success.read(iprot)
6121 
        else:
6122 
          iprot.skip(ftype)
6123 
      elif fid == 1:
6124 
        if ftype == TType.STRUCT:
6125 
          self.cex = InventoryServiceException()
6126 
          self.cex.read(iprot)
6127 
        else:
6128 
          iprot.skip(ftype)
6129 
      else:
6130 
        iprot.skip(ftype)
6131 
      iprot.readFieldEnd()
6132 
    iprot.readStructEnd()
6133 
 
6134 
  def write(self, oprot):
6135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6137 
      return
6138 
    oprot.writeStructBegin('getWarehouse_result')
6139 
    if self.success is not None:
6140 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6141 
      self.success.write(oprot)
6142 
      oprot.writeFieldEnd()
6143 
    if self.cex is not None:
6144 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6145 
      self.cex.write(oprot)
6146 
      oprot.writeFieldEnd()
6147 
    oprot.writeFieldStop()
6148 
    oprot.writeStructEnd()
6149 
 
6150 
  def validate(self):
6151 
    return
6152 
 
6153 
 
6154 
  def __repr__(self):
6155 
    L = ['%s=%r' % (key, value)
6156 
      for key, value in self.__dict__.iteritems()]
6157 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6158 
 
6159 
  def __eq__(self, other):
6160 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6161 
 
6162 
  def __ne__(self, other):
6163 
    return not (self == other)
6164 
 
6165 
class getAllItemsForWarehouse_args:
6166 
  """
6167 
  Attributes:
6168 
   - warehouse_id
6169 
  """
6170 
 
6171 
  thrift_spec = (
6172 
    None, # 0
6173 
    (1, TType.I64, 'warehouse_id', None, None, ), # 1
6174 
  )
6175 
 
6176 
  def __init__(self, warehouse_id=None,):
6177 
    self.warehouse_id = warehouse_id
6178 
 
6179 
  def read(self, iprot):
6180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6182 
      return
6183 
    iprot.readStructBegin()
6184 
    while True:
6185 
      (fname, ftype, fid) = iprot.readFieldBegin()
6186 
      if ftype == TType.STOP:
6187 
        break
6188 
      if fid == 1:
6189 
        if ftype == TType.I64:
6190 
          self.warehouse_id = iprot.readI64();
6191 
        else:
6192 
          iprot.skip(ftype)
6193 
      else:
6194 
        iprot.skip(ftype)
6195 
      iprot.readFieldEnd()
6196 
    iprot.readStructEnd()
6197 
 
6198 
  def write(self, oprot):
6199 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6200 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6201 
      return
6202 
    oprot.writeStructBegin('getAllItemsForWarehouse_args')
6203 
    if self.warehouse_id is not None:
6204 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 1)
6205 
      oprot.writeI64(self.warehouse_id)
6206 
      oprot.writeFieldEnd()
6207 
    oprot.writeFieldStop()
6208 
    oprot.writeStructEnd()
6209 
 
6210 
  def validate(self):
6211 
    return
6212 
 
6213 
 
6214 
  def __repr__(self):
6215 
    L = ['%s=%r' % (key, value)
6216 
      for key, value in self.__dict__.iteritems()]
6217 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6218 
 
6219 
  def __eq__(self, other):
6220 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6221 
 
6222 
  def __ne__(self, other):
6223 
    return not (self == other)
6224 
 
6225 
class getAllItemsForWarehouse_result:
6226 
  """
6227 
  Attributes:
6228 
   - success
6229 
   - cex
6230 
  """
6231 
 
6232 
  thrift_spec = (
6233 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6234 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
6235 
  )
6236 
 
6237 
  def __init__(self, success=None, cex=None,):
6238 
    self.success = success
6239 
    self.cex = cex
6240 
 
6241 
  def read(self, iprot):
6242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6244 
      return
6245 
    iprot.readStructBegin()
6246 
    while True:
6247 
      (fname, ftype, fid) = iprot.readFieldBegin()
6248 
      if ftype == TType.STOP:
6249 
        break
6250 
      if fid == 0:
6251 
        if ftype == TType.LIST:
6252 
          self.success = []
8182 amar.kumar 6253 
          (_etype62, _size59) = iprot.readListBegin()
6254 
          for _i63 in xrange(_size59):
6255 
            _elem64 = iprot.readI64();
6256 
            self.success.append(_elem64)
5944 mandeep.dh 6257 
          iprot.readListEnd()
6258 
        else:
6259 
          iprot.skip(ftype)
6260 
      elif fid == 1:
6261 
        if ftype == TType.STRUCT:
6262 
          self.cex = InventoryServiceException()
6263 
          self.cex.read(iprot)
6264 
        else:
6265 
          iprot.skip(ftype)
6266 
      else:
6267 
        iprot.skip(ftype)
6268 
      iprot.readFieldEnd()
6269 
    iprot.readStructEnd()
6270 
 
6271 
  def write(self, oprot):
6272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6274 
      return
6275 
    oprot.writeStructBegin('getAllItemsForWarehouse_result')
6276 
    if self.success is not None:
6277 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6278 
      oprot.writeListBegin(TType.I64, len(self.success))
8182 amar.kumar 6279 
      for iter65 in self.success:
6280 
        oprot.writeI64(iter65)
5944 mandeep.dh 6281 
      oprot.writeListEnd()
6282 
      oprot.writeFieldEnd()
6283 
    if self.cex is not None:
6284 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6285 
      self.cex.write(oprot)
6286 
      oprot.writeFieldEnd()
6287 
    oprot.writeFieldStop()
6288 
    oprot.writeStructEnd()
6289 
 
6290 
  def validate(self):
6291 
    return
6292 
 
6293 
 
6294 
  def __repr__(self):
6295 
    L = ['%s=%r' % (key, value)
6296 
      for key, value in self.__dict__.iteritems()]
6297 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6298 
 
6299 
  def __eq__(self, other):
6300 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6301 
 
6302 
  def __ne__(self, other):
6303 
    return not (self == other)
6304 
 
5966 rajveer 6305 
class isOrderBillable_args:
6306 
  """
6307 
  Attributes:
6308 
   - itemId
6309 
   - warehouseId
6310 
   - sourceId
6311 
   - orderId
6312 
  """
6313 
 
6314 
  thrift_spec = (
6315 
    None, # 0
6316 
    (1, TType.I64, 'itemId', None, None, ), # 1
6317 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
6318 
    (3, TType.I64, 'sourceId', None, None, ), # 3
6319 
    (4, TType.I64, 'orderId', None, None, ), # 4
6320 
  )
6321 
 
6322 
  def __init__(self, itemId=None, warehouseId=None, sourceId=None, orderId=None,):
6323 
    self.itemId = itemId
6324 
    self.warehouseId = warehouseId
6325 
    self.sourceId = sourceId
6326 
    self.orderId = orderId
6327 
 
6328 
  def read(self, iprot):
6329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6331 
      return
6332 
    iprot.readStructBegin()
6333 
    while True:
6334 
      (fname, ftype, fid) = iprot.readFieldBegin()
6335 
      if ftype == TType.STOP:
6336 
        break
6337 
      if fid == 1:
6338 
        if ftype == TType.I64:
6339 
          self.itemId = iprot.readI64();
6340 
        else:
6341 
          iprot.skip(ftype)
6342 
      elif fid == 2:
6343 
        if ftype == TType.I64:
6344 
          self.warehouseId = iprot.readI64();
6345 
        else:
6346 
          iprot.skip(ftype)
6347 
      elif fid == 3:
6348 
        if ftype == TType.I64:
6349 
          self.sourceId = iprot.readI64();
6350 
        else:
6351 
          iprot.skip(ftype)
6352 
      elif fid == 4:
6353 
        if ftype == TType.I64:
6354 
          self.orderId = iprot.readI64();
6355 
        else:
6356 
          iprot.skip(ftype)
6357 
      else:
6358 
        iprot.skip(ftype)
6359 
      iprot.readFieldEnd()
6360 
    iprot.readStructEnd()
6361 
 
6362 
  def write(self, oprot):
6363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6365 
      return
6366 
    oprot.writeStructBegin('isOrderBillable_args')
6367 
    if self.itemId is not None:
6368 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
6369 
      oprot.writeI64(self.itemId)
6370 
      oprot.writeFieldEnd()
6371 
    if self.warehouseId is not None:
6372 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
6373 
      oprot.writeI64(self.warehouseId)
6374 
      oprot.writeFieldEnd()
6375 
    if self.sourceId is not None:
6376 
      oprot.writeFieldBegin('sourceId', TType.I64, 3)
6377 
      oprot.writeI64(self.sourceId)
6378 
      oprot.writeFieldEnd()
6379 
    if self.orderId is not None:
6380 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
6381 
      oprot.writeI64(self.orderId)
6382 
      oprot.writeFieldEnd()
6383 
    oprot.writeFieldStop()
6384 
    oprot.writeStructEnd()
6385 
 
6386 
  def validate(self):
6387 
    return
6388 
 
6389 
 
6390 
  def __repr__(self):
6391 
    L = ['%s=%r' % (key, value)
6392 
      for key, value in self.__dict__.iteritems()]
6393 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6394 
 
6395 
  def __eq__(self, other):
6396 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6397 
 
6398 
  def __ne__(self, other):
6399 
    return not (self == other)
6400 
 
6401 
class isOrderBillable_result:
6402 
  """
6403 
  Attributes:
6404 
   - success
6405 
  """
6406 
 
6407 
  thrift_spec = (
6408 
    (0, TType.BOOL, 'success', None, None, ), # 0
6409 
  )
6410 
 
6411 
  def __init__(self, success=None,):
6412 
    self.success = success
6413 
 
6414 
  def read(self, iprot):
6415 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6416 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6417 
      return
6418 
    iprot.readStructBegin()
6419 
    while True:
6420 
      (fname, ftype, fid) = iprot.readFieldBegin()
6421 
      if ftype == TType.STOP:
6422 
        break
6423 
      if fid == 0:
6424 
        if ftype == TType.BOOL:
6425 
          self.success = iprot.readBool();
6426 
        else:
6427 
          iprot.skip(ftype)
6428 
      else:
6429 
        iprot.skip(ftype)
6430 
      iprot.readFieldEnd()
6431 
    iprot.readStructEnd()
6432 
 
6433 
  def write(self, oprot):
6434 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6435 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6436 
      return
6437 
    oprot.writeStructBegin('isOrderBillable_result')
6438 
    if self.success is not None:
6439 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6440 
      oprot.writeBool(self.success)
6441 
      oprot.writeFieldEnd()
6442 
    oprot.writeFieldStop()
6443 
    oprot.writeStructEnd()
6444 
 
6445 
  def validate(self):
6446 
    return
6447 
 
6448 
 
6449 
  def __repr__(self):
6450 
    L = ['%s=%r' % (key, value)
6451 
      for key, value in self.__dict__.iteritems()]
6452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6453 
 
6454 
  def __eq__(self, other):
6455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6456 
 
6457 
  def __ne__(self, other):
6458 
    return not (self == other)
6459 
 
5944 mandeep.dh 6460 
class reserveItemInWarehouse_args:
6461 
  """
6462 
  Attributes:
6463 
   - itemId
6464 
   - warehouseId
5966 rajveer 6465 
   - sourceId
6466 
   - orderId
6467 
   - createdTimestamp
6468 
   - promisedShippingTimestamp
5944 mandeep.dh 6469 
   - quantity
6470 
  """
6471 
 
6472 
  thrift_spec = (
6473 
    None, # 0
6474 
    (1, TType.I64, 'itemId', None, None, ), # 1
6475 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
5966 rajveer 6476 
    (3, TType.I64, 'sourceId', None, None, ), # 3
6477 
    (4, TType.I64, 'orderId', None, None, ), # 4
6478 
    (5, TType.I64, 'createdTimestamp', None, None, ), # 5
6479 
    (6, TType.I64, 'promisedShippingTimestamp', None, None, ), # 6
6480 
    (7, TType.DOUBLE, 'quantity', None, None, ), # 7
5944 mandeep.dh 6481 
  )
6482 
 
5966 rajveer 6483 
  def __init__(self, itemId=None, warehouseId=None, sourceId=None, orderId=None, createdTimestamp=None, promisedShippingTimestamp=None, quantity=None,):
5944 mandeep.dh 6484 
    self.itemId = itemId
6485 
    self.warehouseId = warehouseId
5966 rajveer 6486 
    self.sourceId = sourceId
6487 
    self.orderId = orderId
6488 
    self.createdTimestamp = createdTimestamp
6489 
    self.promisedShippingTimestamp = promisedShippingTimestamp
5944 mandeep.dh 6490 
    self.quantity = quantity
6491 
 
6492 
  def read(self, iprot):
6493 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6494 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6495 
      return
6496 
    iprot.readStructBegin()
6497 
    while True:
6498 
      (fname, ftype, fid) = iprot.readFieldBegin()
6499 
      if ftype == TType.STOP:
6500 
        break
6501 
      if fid == 1:
6502 
        if ftype == TType.I64:
6503 
          self.itemId = iprot.readI64();
6504 
        else:
6505 
          iprot.skip(ftype)
6506 
      elif fid == 2:
6507 
        if ftype == TType.I64:
6508 
          self.warehouseId = iprot.readI64();
6509 
        else:
6510 
          iprot.skip(ftype)
6511 
      elif fid == 3:
5966 rajveer 6512 
        if ftype == TType.I64:
6513 
          self.sourceId = iprot.readI64();
6514 
        else:
6515 
          iprot.skip(ftype)
6516 
      elif fid == 4:
6517 
        if ftype == TType.I64:
6518 
          self.orderId = iprot.readI64();
6519 
        else:
6520 
          iprot.skip(ftype)
6521 
      elif fid == 5:
6522 
        if ftype == TType.I64:
6523 
          self.createdTimestamp = iprot.readI64();
6524 
        else:
6525 
          iprot.skip(ftype)
6526 
      elif fid == 6:
6527 
        if ftype == TType.I64:
6528 
          self.promisedShippingTimestamp = iprot.readI64();
6529 
        else:
6530 
          iprot.skip(ftype)
6531 
      elif fid == 7:
5944 mandeep.dh 6532 
        if ftype == TType.DOUBLE:
6533 
          self.quantity = iprot.readDouble();
6534 
        else:
6535 
          iprot.skip(ftype)
6536 
      else:
6537 
        iprot.skip(ftype)
6538 
      iprot.readFieldEnd()
6539 
    iprot.readStructEnd()
6540 
 
6541 
  def write(self, oprot):
6542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6544 
      return
6545 
    oprot.writeStructBegin('reserveItemInWarehouse_args')
6546 
    if self.itemId is not None:
6547 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
6548 
      oprot.writeI64(self.itemId)
6549 
      oprot.writeFieldEnd()
6550 
    if self.warehouseId is not None:
6551 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
6552 
      oprot.writeI64(self.warehouseId)
6553 
      oprot.writeFieldEnd()
5966 rajveer 6554 
    if self.sourceId is not None:
6555 
      oprot.writeFieldBegin('sourceId', TType.I64, 3)
6556 
      oprot.writeI64(self.sourceId)
6557 
      oprot.writeFieldEnd()
6558 
    if self.orderId is not None:
6559 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
6560 
      oprot.writeI64(self.orderId)
6561 
      oprot.writeFieldEnd()
6562 
    if self.createdTimestamp is not None:
6563 
      oprot.writeFieldBegin('createdTimestamp', TType.I64, 5)
6564 
      oprot.writeI64(self.createdTimestamp)
6565 
      oprot.writeFieldEnd()
6566 
    if self.promisedShippingTimestamp is not None:
6567 
      oprot.writeFieldBegin('promisedShippingTimestamp', TType.I64, 6)
6568 
      oprot.writeI64(self.promisedShippingTimestamp)
6569 
      oprot.writeFieldEnd()
5944 mandeep.dh 6570 
    if self.quantity is not None:
5966 rajveer 6571 
      oprot.writeFieldBegin('quantity', TType.DOUBLE, 7)
5944 mandeep.dh 6572 
      oprot.writeDouble(self.quantity)
6573 
      oprot.writeFieldEnd()
6574 
    oprot.writeFieldStop()
6575 
    oprot.writeStructEnd()
6576 
 
6577 
  def validate(self):
6578 
    return
6579 
 
6580 
 
6581 
  def __repr__(self):
6582 
    L = ['%s=%r' % (key, value)
6583 
      for key, value in self.__dict__.iteritems()]
6584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6585 
 
6586 
  def __eq__(self, other):
6587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6588 
 
6589 
  def __ne__(self, other):
6590 
    return not (self == other)
6591 
 
6592 
class reserveItemInWarehouse_result:
6593 
  """
6594 
  Attributes:
6595 
   - success
6596 
   - cex
6597 
  """
6598 
 
6599 
  thrift_spec = (
6600 
    (0, TType.BOOL, 'success', None, None, ), # 0
6601 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
6602 
  )
6603 
 
6604 
  def __init__(self, success=None, cex=None,):
6605 
    self.success = success
6606 
    self.cex = cex
6607 
 
6608 
  def read(self, iprot):
6609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6611 
      return
6612 
    iprot.readStructBegin()
6613 
    while True:
6614 
      (fname, ftype, fid) = iprot.readFieldBegin()
6615 
      if ftype == TType.STOP:
6616 
        break
6617 
      if fid == 0:
6618 
        if ftype == TType.BOOL:
6619 
          self.success = iprot.readBool();
6620 
        else:
6621 
          iprot.skip(ftype)
6622 
      elif fid == 1:
6623 
        if ftype == TType.STRUCT:
6624 
          self.cex = InventoryServiceException()
6625 
          self.cex.read(iprot)
6626 
        else:
6627 
          iprot.skip(ftype)
6628 
      else:
6629 
        iprot.skip(ftype)
6630 
      iprot.readFieldEnd()
6631 
    iprot.readStructEnd()
6632 
 
6633 
  def write(self, oprot):
6634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6636 
      return
6637 
    oprot.writeStructBegin('reserveItemInWarehouse_result')
6638 
    if self.success is not None:
6639 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6640 
      oprot.writeBool(self.success)
6641 
      oprot.writeFieldEnd()
6642 
    if self.cex is not None:
6643 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6644 
      self.cex.write(oprot)
6645 
      oprot.writeFieldEnd()
6646 
    oprot.writeFieldStop()
6647 
    oprot.writeStructEnd()
6648 
 
6649 
  def validate(self):
6650 
    return
6651 
 
6652 
 
6653 
  def __repr__(self):
6654 
    L = ['%s=%r' % (key, value)
6655 
      for key, value in self.__dict__.iteritems()]
6656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6657 
 
6658 
  def __eq__(self, other):
6659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6660 
 
6661 
  def __ne__(self, other):
6662 
    return not (self == other)
6663 
 
7968 amar.kumar 6664 
class updateReservationForOrder_args:
6665 
  """
6666 
  Attributes:
6667 
   - itemId
6668 
   - warehouseId
6669 
   - sourceId
6670 
   - orderId
6671 
   - createdTimestamp
6672 
   - promisedShippingTimestamp
6673 
   - quantity
6674 
  """
6675 
 
6676 
  thrift_spec = (
6677 
    None, # 0
6678 
    (1, TType.I64, 'itemId', None, None, ), # 1
6679 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
6680 
    (3, TType.I64, 'sourceId', None, None, ), # 3
6681 
    (4, TType.I64, 'orderId', None, None, ), # 4
6682 
    (5, TType.I64, 'createdTimestamp', None, None, ), # 5
6683 
    (6, TType.I64, 'promisedShippingTimestamp', None, None, ), # 6
6684 
    (7, TType.DOUBLE, 'quantity', None, None, ), # 7
6685 
  )
6686 
 
6687 
  def __init__(self, itemId=None, warehouseId=None, sourceId=None, orderId=None, createdTimestamp=None, promisedShippingTimestamp=None, quantity=None,):
6688 
    self.itemId = itemId
6689 
    self.warehouseId = warehouseId
6690 
    self.sourceId = sourceId
6691 
    self.orderId = orderId
6692 
    self.createdTimestamp = createdTimestamp
6693 
    self.promisedShippingTimestamp = promisedShippingTimestamp
6694 
    self.quantity = quantity
6695 
 
6696 
  def read(self, iprot):
6697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6699 
      return
6700 
    iprot.readStructBegin()
6701 
    while True:
6702 
      (fname, ftype, fid) = iprot.readFieldBegin()
6703 
      if ftype == TType.STOP:
6704 
        break
6705 
      if fid == 1:
6706 
        if ftype == TType.I64:
6707 
          self.itemId = iprot.readI64();
6708 
        else:
6709 
          iprot.skip(ftype)
6710 
      elif fid == 2:
6711 
        if ftype == TType.I64:
6712 
          self.warehouseId = iprot.readI64();
6713 
        else:
6714 
          iprot.skip(ftype)
6715 
      elif fid == 3:
6716 
        if ftype == TType.I64:
6717 
          self.sourceId = iprot.readI64();
6718 
        else:
6719 
          iprot.skip(ftype)
6720 
      elif fid == 4:
6721 
        if ftype == TType.I64:
6722 
          self.orderId = iprot.readI64();
6723 
        else:
6724 
          iprot.skip(ftype)
6725 
      elif fid == 5:
6726 
        if ftype == TType.I64:
6727 
          self.createdTimestamp = iprot.readI64();
6728 
        else:
6729 
          iprot.skip(ftype)
6730 
      elif fid == 6:
6731 
        if ftype == TType.I64:
6732 
          self.promisedShippingTimestamp = iprot.readI64();
6733 
        else:
6734 
          iprot.skip(ftype)
6735 
      elif fid == 7:
6736 
        if ftype == TType.DOUBLE:
6737 
          self.quantity = iprot.readDouble();
6738 
        else:
6739 
          iprot.skip(ftype)
6740 
      else:
6741 
        iprot.skip(ftype)
6742 
      iprot.readFieldEnd()
6743 
    iprot.readStructEnd()
6744 
 
6745 
  def write(self, oprot):
6746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6748 
      return
6749 
    oprot.writeStructBegin('updateReservationForOrder_args')
6750 
    if self.itemId is not None:
6751 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
6752 
      oprot.writeI64(self.itemId)
6753 
      oprot.writeFieldEnd()
6754 
    if self.warehouseId is not None:
6755 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
6756 
      oprot.writeI64(self.warehouseId)
6757 
      oprot.writeFieldEnd()
6758 
    if self.sourceId is not None:
6759 
      oprot.writeFieldBegin('sourceId', TType.I64, 3)
6760 
      oprot.writeI64(self.sourceId)
6761 
      oprot.writeFieldEnd()
6762 
    if self.orderId is not None:
6763 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
6764 
      oprot.writeI64(self.orderId)
6765 
      oprot.writeFieldEnd()
6766 
    if self.createdTimestamp is not None:
6767 
      oprot.writeFieldBegin('createdTimestamp', TType.I64, 5)
6768 
      oprot.writeI64(self.createdTimestamp)
6769 
      oprot.writeFieldEnd()
6770 
    if self.promisedShippingTimestamp is not None:
6771 
      oprot.writeFieldBegin('promisedShippingTimestamp', TType.I64, 6)
6772 
      oprot.writeI64(self.promisedShippingTimestamp)
6773 
      oprot.writeFieldEnd()
6774 
    if self.quantity is not None:
6775 
      oprot.writeFieldBegin('quantity', TType.DOUBLE, 7)
6776 
      oprot.writeDouble(self.quantity)
6777 
      oprot.writeFieldEnd()
6778 
    oprot.writeFieldStop()
6779 
    oprot.writeStructEnd()
6780 
 
6781 
  def validate(self):
6782 
    return
6783 
 
6784 
 
6785 
  def __repr__(self):
6786 
    L = ['%s=%r' % (key, value)
6787 
      for key, value in self.__dict__.iteritems()]
6788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6789 
 
6790 
  def __eq__(self, other):
6791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6792 
 
6793 
  def __ne__(self, other):
6794 
    return not (self == other)
6795 
 
6796 
class updateReservationForOrder_result:
6797 
  """
6798 
  Attributes:
6799 
   - success
6800 
   - cex
6801 
  """
6802 
 
6803 
  thrift_spec = (
6804 
    (0, TType.BOOL, 'success', None, None, ), # 0
6805 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
6806 
  )
6807 
 
6808 
  def __init__(self, success=None, cex=None,):
6809 
    self.success = success
6810 
    self.cex = cex
6811 
 
6812 
  def read(self, iprot):
6813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6815 
      return
6816 
    iprot.readStructBegin()
6817 
    while True:
6818 
      (fname, ftype, fid) = iprot.readFieldBegin()
6819 
      if ftype == TType.STOP:
6820 
        break
6821 
      if fid == 0:
6822 
        if ftype == TType.BOOL:
6823 
          self.success = iprot.readBool();
6824 
        else:
6825 
          iprot.skip(ftype)
6826 
      elif fid == 1:
6827 
        if ftype == TType.STRUCT:
6828 
          self.cex = InventoryServiceException()
6829 
          self.cex.read(iprot)
6830 
        else:
6831 
          iprot.skip(ftype)
6832 
      else:
6833 
        iprot.skip(ftype)
6834 
      iprot.readFieldEnd()
6835 
    iprot.readStructEnd()
6836 
 
6837 
  def write(self, oprot):
6838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6840 
      return
6841 
    oprot.writeStructBegin('updateReservationForOrder_result')
6842 
    if self.success is not None:
6843 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6844 
      oprot.writeBool(self.success)
6845 
      oprot.writeFieldEnd()
6846 
    if self.cex is not None:
6847 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6848 
      self.cex.write(oprot)
6849 
      oprot.writeFieldEnd()
6850 
    oprot.writeFieldStop()
6851 
    oprot.writeStructEnd()
6852 
 
6853 
  def validate(self):
6854 
    return
6855 
 
6856 
 
6857 
  def __repr__(self):
6858 
    L = ['%s=%r' % (key, value)
6859 
      for key, value in self.__dict__.iteritems()]
6860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6861 
 
6862 
  def __eq__(self, other):
6863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6864 
 
6865 
  def __ne__(self, other):
6866 
    return not (self == other)
6867 
 
5944 mandeep.dh 6868 
class reduceReservationCount_args:
6869 
  """
6870 
  Attributes:
6871 
   - itemId
6872 
   - warehouseId
5966 rajveer 6873 
   - sourceId
6874 
   - orderId
5944 mandeep.dh 6875 
   - quantity
6876 
  """
6877 
 
6878 
  thrift_spec = (
6879 
    None, # 0
6880 
    (1, TType.I64, 'itemId', None, None, ), # 1
6881 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
5966 rajveer 6882 
    (3, TType.I64, 'sourceId', None, None, ), # 3
6883 
    (4, TType.I64, 'orderId', None, None, ), # 4
6884 
    (5, TType.DOUBLE, 'quantity', None, None, ), # 5
5944 mandeep.dh 6885 
  )
6886 
 
5966 rajveer 6887 
  def __init__(self, itemId=None, warehouseId=None, sourceId=None, orderId=None, quantity=None,):
5944 mandeep.dh 6888 
    self.itemId = itemId
6889 
    self.warehouseId = warehouseId
5966 rajveer 6890 
    self.sourceId = sourceId
6891 
    self.orderId = orderId
5944 mandeep.dh 6892 
    self.quantity = quantity
6893 
 
6894 
  def read(self, iprot):
6895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6897 
      return
6898 
    iprot.readStructBegin()
6899 
    while True:
6900 
      (fname, ftype, fid) = iprot.readFieldBegin()
6901 
      if ftype == TType.STOP:
6902 
        break
6903 
      if fid == 1:
6904 
        if ftype == TType.I64:
6905 
          self.itemId = iprot.readI64();
6906 
        else:
6907 
          iprot.skip(ftype)
6908 
      elif fid == 2:
6909 
        if ftype == TType.I64:
6910 
          self.warehouseId = iprot.readI64();
6911 
        else:
6912 
          iprot.skip(ftype)
6913 
      elif fid == 3:
5966 rajveer 6914 
        if ftype == TType.I64:
6915 
          self.sourceId = iprot.readI64();
6916 
        else:
6917 
          iprot.skip(ftype)
6918 
      elif fid == 4:
6919 
        if ftype == TType.I64:
6920 
          self.orderId = iprot.readI64();
6921 
        else:
6922 
          iprot.skip(ftype)
6923 
      elif fid == 5:
5944 mandeep.dh 6924 
        if ftype == TType.DOUBLE:
6925 
          self.quantity = iprot.readDouble();
6926 
        else:
6927 
          iprot.skip(ftype)
6928 
      else:
6929 
        iprot.skip(ftype)
6930 
      iprot.readFieldEnd()
6931 
    iprot.readStructEnd()
6932 
 
6933 
  def write(self, oprot):
6934 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6935 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6936 
      return
6937 
    oprot.writeStructBegin('reduceReservationCount_args')
6938 
    if self.itemId is not None:
6939 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
6940 
      oprot.writeI64(self.itemId)
6941 
      oprot.writeFieldEnd()
6942 
    if self.warehouseId is not None:
6943 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
6944 
      oprot.writeI64(self.warehouseId)
6945 
      oprot.writeFieldEnd()
5966 rajveer 6946 
    if self.sourceId is not None:
6947 
      oprot.writeFieldBegin('sourceId', TType.I64, 3)
6948 
      oprot.writeI64(self.sourceId)
6949 
      oprot.writeFieldEnd()
6950 
    if self.orderId is not None:
6951 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
6952 
      oprot.writeI64(self.orderId)
6953 
      oprot.writeFieldEnd()
5944 mandeep.dh 6954 
    if self.quantity is not None:
5966 rajveer 6955 
      oprot.writeFieldBegin('quantity', TType.DOUBLE, 5)
5944 mandeep.dh 6956 
      oprot.writeDouble(self.quantity)
6957 
      oprot.writeFieldEnd()
6958 
    oprot.writeFieldStop()
6959 
    oprot.writeStructEnd()
6960 
 
6961 
  def validate(self):
6962 
    return
6963 
 
6964 
 
6965 
  def __repr__(self):
6966 
    L = ['%s=%r' % (key, value)
6967 
      for key, value in self.__dict__.iteritems()]
6968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6969 
 
6970 
  def __eq__(self, other):
6971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6972 
 
6973 
  def __ne__(self, other):
6974 
    return not (self == other)
6975 
 
6976 
class reduceReservationCount_result:
6977 
  """
6978 
  Attributes:
6979 
   - success
6980 
   - cex
6981 
  """
6982 
 
6983 
  thrift_spec = (
6984 
    (0, TType.BOOL, 'success', None, None, ), # 0
6985 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
6986 
  )
6987 
 
6988 
  def __init__(self, success=None, cex=None,):
6989 
    self.success = success
6990 
    self.cex = cex
6991 
 
6992 
  def read(self, iprot):
6993 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6994 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6995 
      return
6996 
    iprot.readStructBegin()
6997 
    while True:
6998 
      (fname, ftype, fid) = iprot.readFieldBegin()
6999 
      if ftype == TType.STOP:
7000 
        break
7001 
      if fid == 0:
7002 
        if ftype == TType.BOOL:
7003 
          self.success = iprot.readBool();
7004 
        else:
7005 
          iprot.skip(ftype)
7006 
      elif fid == 1:
7007 
        if ftype == TType.STRUCT:
7008 
          self.cex = InventoryServiceException()
7009 
          self.cex.read(iprot)
7010 
        else:
7011 
          iprot.skip(ftype)
7012 
      else:
7013 
        iprot.skip(ftype)
7014 
      iprot.readFieldEnd()
7015 
    iprot.readStructEnd()
7016 
 
7017 
  def write(self, oprot):
7018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7020 
      return
7021 
    oprot.writeStructBegin('reduceReservationCount_result')
7022 
    if self.success is not None:
7023 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7024 
      oprot.writeBool(self.success)
7025 
      oprot.writeFieldEnd()
7026 
    if self.cex is not None:
7027 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7028 
      self.cex.write(oprot)
7029 
      oprot.writeFieldEnd()
7030 
    oprot.writeFieldStop()
7031 
    oprot.writeStructEnd()
7032 
 
7033 
  def validate(self):
7034 
    return
7035 
 
7036 
 
7037 
  def __repr__(self):
7038 
    L = ['%s=%r' % (key, value)
7039 
      for key, value in self.__dict__.iteritems()]
7040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7041 
 
7042 
  def __eq__(self, other):
7043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7044 
 
7045 
  def __ne__(self, other):
7046 
    return not (self == other)
7047 
 
7048 
class getItemPricing_args:
7049 
  """
7050 
  Attributes:
7051 
   - itemId
7052 
   - vendorId
7053 
  """
7054 
 
7055 
  thrift_spec = (
7056 
    None, # 0
7057 
    (1, TType.I64, 'itemId', None, None, ), # 1
7058 
    (2, TType.I64, 'vendorId', None, None, ), # 2
7059 
  )
7060 
 
7061 
  def __init__(self, itemId=None, vendorId=None,):
7062 
    self.itemId = itemId
7063 
    self.vendorId = vendorId
7064 
 
7065 
  def read(self, iprot):
7066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7068 
      return
7069 
    iprot.readStructBegin()
7070 
    while True:
7071 
      (fname, ftype, fid) = iprot.readFieldBegin()
7072 
      if ftype == TType.STOP:
7073 
        break
7074 
      if fid == 1:
7075 
        if ftype == TType.I64:
7076 
          self.itemId = iprot.readI64();
7077 
        else:
7078 
          iprot.skip(ftype)
7079 
      elif fid == 2:
7080 
        if ftype == TType.I64:
7081 
          self.vendorId = iprot.readI64();
7082 
        else:
7083 
          iprot.skip(ftype)
7084 
      else:
7085 
        iprot.skip(ftype)
7086 
      iprot.readFieldEnd()
7087 
    iprot.readStructEnd()
7088 
 
7089 
  def write(self, oprot):
7090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7092 
      return
7093 
    oprot.writeStructBegin('getItemPricing_args')
7094 
    if self.itemId is not None:
7095 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
7096 
      oprot.writeI64(self.itemId)
7097 
      oprot.writeFieldEnd()
7098 
    if self.vendorId is not None:
7099 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
7100 
      oprot.writeI64(self.vendorId)
7101 
      oprot.writeFieldEnd()
7102 
    oprot.writeFieldStop()
7103 
    oprot.writeStructEnd()
7104 
 
7105 
  def validate(self):
7106 
    return
7107 
 
7108 
 
7109 
  def __repr__(self):
7110 
    L = ['%s=%r' % (key, value)
7111 
      for key, value in self.__dict__.iteritems()]
7112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7113 
 
7114 
  def __eq__(self, other):
7115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7116 
 
7117 
  def __ne__(self, other):
7118 
    return not (self == other)
7119 
 
7120 
class getItemPricing_result:
7121 
  """
7122 
  Attributes:
7123 
   - success
7124 
   - cex
7125 
  """
7126 
 
7127 
  thrift_spec = (
7128 
    (0, TType.STRUCT, 'success', (VendorItemPricing, VendorItemPricing.thrift_spec), None, ), # 0
7129 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
7130 
  )
7131 
 
7132 
  def __init__(self, success=None, cex=None,):
7133 
    self.success = success
7134 
    self.cex = cex
7135 
 
7136 
  def read(self, iprot):
7137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7139 
      return
7140 
    iprot.readStructBegin()
7141 
    while True:
7142 
      (fname, ftype, fid) = iprot.readFieldBegin()
7143 
      if ftype == TType.STOP:
7144 
        break
7145 
      if fid == 0:
7146 
        if ftype == TType.STRUCT:
7147 
          self.success = VendorItemPricing()
7148 
          self.success.read(iprot)
7149 
        else:
7150 
          iprot.skip(ftype)
7151 
      elif fid == 1:
7152 
        if ftype == TType.STRUCT:
7153 
          self.cex = InventoryServiceException()
7154 
          self.cex.read(iprot)
7155 
        else:
7156 
          iprot.skip(ftype)
7157 
      else:
7158 
        iprot.skip(ftype)
7159 
      iprot.readFieldEnd()
7160 
    iprot.readStructEnd()
7161 
 
7162 
  def write(self, oprot):
7163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7165 
      return
7166 
    oprot.writeStructBegin('getItemPricing_result')
7167 
    if self.success is not None:
7168 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7169 
      self.success.write(oprot)
7170 
      oprot.writeFieldEnd()
7171 
    if self.cex is not None:
7172 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7173 
      self.cex.write(oprot)
7174 
      oprot.writeFieldEnd()
7175 
    oprot.writeFieldStop()
7176 
    oprot.writeStructEnd()
7177 
 
7178 
  def validate(self):
7179 
    return
7180 
 
7181 
 
7182 
  def __repr__(self):
7183 
    L = ['%s=%r' % (key, value)
7184 
      for key, value in self.__dict__.iteritems()]
7185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7186 
 
7187 
  def __eq__(self, other):
7188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7189 
 
7190 
  def __ne__(self, other):
7191 
    return not (self == other)
7192 
 
7193 
class getAllItemPricing_args:
7194 
  """
7195 
  Attributes:
7196 
   - itemId
7197 
  """
7198 
 
7199 
  thrift_spec = (
7200 
    None, # 0
7201 
    (1, TType.I64, 'itemId', None, None, ), # 1
7202 
  )
7203 
 
7204 
  def __init__(self, itemId=None,):
7205 
    self.itemId = itemId
7206 
 
7207 
  def read(self, iprot):
7208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7210 
      return
7211 
    iprot.readStructBegin()
7212 
    while True:
7213 
      (fname, ftype, fid) = iprot.readFieldBegin()
7214 
      if ftype == TType.STOP:
7215 
        break
7216 
      if fid == 1:
7217 
        if ftype == TType.I64:
7218 
          self.itemId = iprot.readI64();
7219 
        else:
7220 
          iprot.skip(ftype)
7221 
      else:
7222 
        iprot.skip(ftype)
7223 
      iprot.readFieldEnd()
7224 
    iprot.readStructEnd()
7225 
 
7226 
  def write(self, oprot):
7227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7229 
      return
7230 
    oprot.writeStructBegin('getAllItemPricing_args')
7231 
    if self.itemId is not None:
7232 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
7233 
      oprot.writeI64(self.itemId)
7234 
      oprot.writeFieldEnd()
7235 
    oprot.writeFieldStop()
7236 
    oprot.writeStructEnd()
7237 
 
7238 
  def validate(self):
7239 
    return
7240 
 
7241 
 
7242 
  def __repr__(self):
7243 
    L = ['%s=%r' % (key, value)
7244 
      for key, value in self.__dict__.iteritems()]
7245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7246 
 
7247 
  def __eq__(self, other):
7248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7249 
 
7250 
  def __ne__(self, other):
7251 
    return not (self == other)
7252 
 
7253 
class getAllItemPricing_result:
7254 
  """
7255 
  Attributes:
7256 
   - success
7257 
   - cex
7258 
  """
7259 
 
7260 
  thrift_spec = (
7261 
    (0, TType.LIST, 'success', (TType.STRUCT,(VendorItemPricing, VendorItemPricing.thrift_spec)), None, ), # 0
7262 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
7263 
  )
7264 
 
7265 
  def __init__(self, success=None, cex=None,):
7266 
    self.success = success
7267 
    self.cex = cex
7268 
 
7269 
  def read(self, iprot):
7270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7272 
      return
7273 
    iprot.readStructBegin()
7274 
    while True:
7275 
      (fname, ftype, fid) = iprot.readFieldBegin()
7276 
      if ftype == TType.STOP:
7277 
        break
7278 
      if fid == 0:
7279 
        if ftype == TType.LIST:
7280 
          self.success = []
8182 amar.kumar 7281 
          (_etype69, _size66) = iprot.readListBegin()
7282 
          for _i70 in xrange(_size66):
7283 
            _elem71 = VendorItemPricing()
7284 
            _elem71.read(iprot)
7285 
            self.success.append(_elem71)
5944 mandeep.dh 7286 
          iprot.readListEnd()
7287 
        else:
7288 
          iprot.skip(ftype)
7289 
      elif fid == 1:
7290 
        if ftype == TType.STRUCT:
7291 
          self.cex = InventoryServiceException()
7292 
          self.cex.read(iprot)
7293 
        else:
7294 
          iprot.skip(ftype)
7295 
      else:
7296 
        iprot.skip(ftype)
7297 
      iprot.readFieldEnd()
7298 
    iprot.readStructEnd()
7299 
 
7300 
  def write(self, oprot):
7301 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7302 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7303 
      return
7304 
    oprot.writeStructBegin('getAllItemPricing_result')
7305 
    if self.success is not None:
7306 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7307 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 7308 
      for iter72 in self.success:
7309 
        iter72.write(oprot)
5944 mandeep.dh 7310 
      oprot.writeListEnd()
7311 
      oprot.writeFieldEnd()
7312 
    if self.cex is not None:
7313 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7314 
      self.cex.write(oprot)
7315 
      oprot.writeFieldEnd()
7316 
    oprot.writeFieldStop()
7317 
    oprot.writeStructEnd()
7318 
 
7319 
  def validate(self):
7320 
    return
7321 
 
7322 
 
7323 
  def __repr__(self):
7324 
    L = ['%s=%r' % (key, value)
7325 
      for key, value in self.__dict__.iteritems()]
7326 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7327 
 
7328 
  def __eq__(self, other):
7329 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7330 
 
7331 
  def __ne__(self, other):
7332 
    return not (self == other)
7333 
 
7334 
class addVendorItemPricing_args:
7335 
  """
7336 
  Attributes:
7337 
   - vendorItemPricing
7338 
  """
7339 
 
7340 
  thrift_spec = (
7341 
    None, # 0
7342 
    (1, TType.STRUCT, 'vendorItemPricing', (VendorItemPricing, VendorItemPricing.thrift_spec), None, ), # 1
7343 
  )
7344 
 
7345 
  def __init__(self, vendorItemPricing=None,):
7346 
    self.vendorItemPricing = vendorItemPricing
7347 
 
7348 
  def read(self, iprot):
7349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7351 
      return
7352 
    iprot.readStructBegin()
7353 
    while True:
7354 
      (fname, ftype, fid) = iprot.readFieldBegin()
7355 
      if ftype == TType.STOP:
7356 
        break
7357 
      if fid == 1:
7358 
        if ftype == TType.STRUCT:
7359 
          self.vendorItemPricing = VendorItemPricing()
7360 
          self.vendorItemPricing.read(iprot)
7361 
        else:
7362 
          iprot.skip(ftype)
7363 
      else:
7364 
        iprot.skip(ftype)
7365 
      iprot.readFieldEnd()
7366 
    iprot.readStructEnd()
7367 
 
7368 
  def write(self, oprot):
7369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7371 
      return
7372 
    oprot.writeStructBegin('addVendorItemPricing_args')
7373 
    if self.vendorItemPricing is not None:
7374 
      oprot.writeFieldBegin('vendorItemPricing', TType.STRUCT, 1)
7375 
      self.vendorItemPricing.write(oprot)
7376 
      oprot.writeFieldEnd()
7377 
    oprot.writeFieldStop()
7378 
    oprot.writeStructEnd()
7379 
 
7380 
  def validate(self):
7381 
    return
7382 
 
7383 
 
7384 
  def __repr__(self):
7385 
    L = ['%s=%r' % (key, value)
7386 
      for key, value in self.__dict__.iteritems()]
7387 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7388 
 
7389 
  def __eq__(self, other):
7390 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7391 
 
7392 
  def __ne__(self, other):
7393 
    return not (self == other)
7394 
 
7395 
class addVendorItemPricing_result:
7396 
  """
7397 
  Attributes:
7398 
   - cex
7399 
  """
7400 
 
7401 
  thrift_spec = (
7402 
    None, # 0
7403 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
7404 
  )
7405 
 
7406 
  def __init__(self, cex=None,):
7407 
    self.cex = cex
7408 
 
7409 
  def read(self, iprot):
7410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7412 
      return
7413 
    iprot.readStructBegin()
7414 
    while True:
7415 
      (fname, ftype, fid) = iprot.readFieldBegin()
7416 
      if ftype == TType.STOP:
7417 
        break
7418 
      if fid == 1:
7419 
        if ftype == TType.STRUCT:
7420 
          self.cex = InventoryServiceException()
7421 
          self.cex.read(iprot)
7422 
        else:
7423 
          iprot.skip(ftype)
7424 
      else:
7425 
        iprot.skip(ftype)
7426 
      iprot.readFieldEnd()
7427 
    iprot.readStructEnd()
7428 
 
7429 
  def write(self, oprot):
7430 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7431 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7432 
      return
7433 
    oprot.writeStructBegin('addVendorItemPricing_result')
7434 
    if self.cex is not None:
7435 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7436 
      self.cex.write(oprot)
7437 
      oprot.writeFieldEnd()
7438 
    oprot.writeFieldStop()
7439 
    oprot.writeStructEnd()
7440 
 
7441 
  def validate(self):
7442 
    return
7443 
 
7444 
 
7445 
  def __repr__(self):
7446 
    L = ['%s=%r' % (key, value)
7447 
      for key, value in self.__dict__.iteritems()]
7448 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7449 
 
7450 
  def __eq__(self, other):
7451 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7452 
 
7453 
  def __ne__(self, other):
7454 
    return not (self == other)
7455 
 
7456 
class getVendor_args:
7457 
  """
7458 
  Attributes:
7459 
   - vendorId
7460 
  """
7461 
 
7462 
  thrift_spec = (
7463 
    None, # 0
7464 
    (1, TType.I64, 'vendorId', None, None, ), # 1
7465 
  )
7466 
 
7467 
  def __init__(self, vendorId=None,):
7468 
    self.vendorId = vendorId
7469 
 
7470 
  def read(self, iprot):
7471 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7472 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7473 
      return
7474 
    iprot.readStructBegin()
7475 
    while True:
7476 
      (fname, ftype, fid) = iprot.readFieldBegin()
7477 
      if ftype == TType.STOP:
7478 
        break
7479 
      if fid == 1:
7480 
        if ftype == TType.I64:
7481 
          self.vendorId = iprot.readI64();
7482 
        else:
7483 
          iprot.skip(ftype)
7484 
      else:
7485 
        iprot.skip(ftype)
7486 
      iprot.readFieldEnd()
7487 
    iprot.readStructEnd()
7488 
 
7489 
  def write(self, oprot):
7490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7492 
      return
7493 
    oprot.writeStructBegin('getVendor_args')
7494 
    if self.vendorId is not None:
7495 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
7496 
      oprot.writeI64(self.vendorId)
7497 
      oprot.writeFieldEnd()
7498 
    oprot.writeFieldStop()
7499 
    oprot.writeStructEnd()
7500 
 
7501 
  def validate(self):
7502 
    return
7503 
 
7504 
 
7505 
  def __repr__(self):
7506 
    L = ['%s=%r' % (key, value)
7507 
      for key, value in self.__dict__.iteritems()]
7508 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7509 
 
7510 
  def __eq__(self, other):
7511 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7512 
 
7513 
  def __ne__(self, other):
7514 
    return not (self == other)
7515 
 
7516 
class getVendor_result:
7517 
  """
7518 
  Attributes:
7519 
   - success
7520 
  """
7521 
 
7522 
  thrift_spec = (
7523 
    (0, TType.STRUCT, 'success', (Vendor, Vendor.thrift_spec), None, ), # 0
7524 
  )
7525 
 
7526 
  def __init__(self, success=None,):
7527 
    self.success = success
7528 
 
7529 
  def read(self, iprot):
7530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7532 
      return
7533 
    iprot.readStructBegin()
7534 
    while True:
7535 
      (fname, ftype, fid) = iprot.readFieldBegin()
7536 
      if ftype == TType.STOP:
7537 
        break
7538 
      if fid == 0:
7539 
        if ftype == TType.STRUCT:
7540 
          self.success = Vendor()
7541 
          self.success.read(iprot)
7542 
        else:
7543 
          iprot.skip(ftype)
7544 
      else:
7545 
        iprot.skip(ftype)
7546 
      iprot.readFieldEnd()
7547 
    iprot.readStructEnd()
7548 
 
7549 
  def write(self, oprot):
7550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7552 
      return
7553 
    oprot.writeStructBegin('getVendor_result')
7554 
    if self.success is not None:
7555 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7556 
      self.success.write(oprot)
7557 
      oprot.writeFieldEnd()
7558 
    oprot.writeFieldStop()
7559 
    oprot.writeStructEnd()
7560 
 
7561 
  def validate(self):
7562 
    return
7563 
 
7564 
 
7565 
  def __repr__(self):
7566 
    L = ['%s=%r' % (key, value)
7567 
      for key, value in self.__dict__.iteritems()]
7568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7569 
 
7570 
  def __eq__(self, other):
7571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7572 
 
7573 
  def __ne__(self, other):
7574 
    return not (self == other)
7575 
 
7576 
class getAllVendors_args:
7577 
 
7578 
  thrift_spec = (
7579 
  )
7580 
 
7581 
  def read(self, iprot):
7582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7584 
      return
7585 
    iprot.readStructBegin()
7586 
    while True:
7587 
      (fname, ftype, fid) = iprot.readFieldBegin()
7588 
      if ftype == TType.STOP:
7589 
        break
7590 
      else:
7591 
        iprot.skip(ftype)
7592 
      iprot.readFieldEnd()
7593 
    iprot.readStructEnd()
7594 
 
7595 
  def write(self, oprot):
7596 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7597 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7598 
      return
7599 
    oprot.writeStructBegin('getAllVendors_args')
7600 
    oprot.writeFieldStop()
7601 
    oprot.writeStructEnd()
7602 
 
7603 
  def validate(self):
7604 
    return
7605 
 
7606 
 
7607 
  def __repr__(self):
7608 
    L = ['%s=%r' % (key, value)
7609 
      for key, value in self.__dict__.iteritems()]
7610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7611 
 
7612 
  def __eq__(self, other):
7613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7614 
 
7615 
  def __ne__(self, other):
7616 
    return not (self == other)
7617 
 
7618 
class getAllVendors_result:
7619 
  """
7620 
  Attributes:
7621 
   - success
7622 
  """
7623 
 
7624 
  thrift_spec = (
7625 
    (0, TType.LIST, 'success', (TType.STRUCT,(Vendor, Vendor.thrift_spec)), None, ), # 0
7626 
  )
7627 
 
7628 
  def __init__(self, success=None,):
7629 
    self.success = success
7630 
 
7631 
  def read(self, iprot):
7632 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7633 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7634 
      return
7635 
    iprot.readStructBegin()
7636 
    while True:
7637 
      (fname, ftype, fid) = iprot.readFieldBegin()
7638 
      if ftype == TType.STOP:
7639 
        break
7640 
      if fid == 0:
7641 
        if ftype == TType.LIST:
7642 
          self.success = []
8182 amar.kumar 7643 
          (_etype76, _size73) = iprot.readListBegin()
7644 
          for _i77 in xrange(_size73):
7645 
            _elem78 = Vendor()
7646 
            _elem78.read(iprot)
7647 
            self.success.append(_elem78)
5944 mandeep.dh 7648 
          iprot.readListEnd()
7649 
        else:
7650 
          iprot.skip(ftype)
7651 
      else:
7652 
        iprot.skip(ftype)
7653 
      iprot.readFieldEnd()
7654 
    iprot.readStructEnd()
7655 
 
7656 
  def write(self, oprot):
7657 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7658 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7659 
      return
7660 
    oprot.writeStructBegin('getAllVendors_result')
7661 
    if self.success is not None:
7662 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7663 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 7664 
      for iter79 in self.success:
7665 
        iter79.write(oprot)
5944 mandeep.dh 7666 
      oprot.writeListEnd()
7667 
      oprot.writeFieldEnd()
7668 
    oprot.writeFieldStop()
7669 
    oprot.writeStructEnd()
7670 
 
7671 
  def validate(self):
7672 
    return
7673 
 
7674 
 
7675 
  def __repr__(self):
7676 
    L = ['%s=%r' % (key, value)
7677 
      for key, value in self.__dict__.iteritems()]
7678 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7679 
 
7680 
  def __eq__(self, other):
7681 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7682 
 
7683 
  def __ne__(self, other):
7684 
    return not (self == other)
7685 
 
7686 
class addVendorItemMapping_args:
7687 
  """
7688 
  Attributes:
7689 
   - key
7690 
   - vendorItemMapping
7691 
  """
7692 
 
7693 
  thrift_spec = (
7694 
    None, # 0
7695 
    (1, TType.STRING, 'key', None, None, ), # 1
7696 
    (2, TType.STRUCT, 'vendorItemMapping', (VendorItemMapping, VendorItemMapping.thrift_spec), None, ), # 2
7697 
  )
7698 
 
7699 
  def __init__(self, key=None, vendorItemMapping=None,):
7700 
    self.key = key
7701 
    self.vendorItemMapping = vendorItemMapping
7702 
 
7703 
  def read(self, iprot):
7704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7706 
      return
7707 
    iprot.readStructBegin()
7708 
    while True:
7709 
      (fname, ftype, fid) = iprot.readFieldBegin()
7710 
      if ftype == TType.STOP:
7711 
        break
7712 
      if fid == 1:
7713 
        if ftype == TType.STRING:
7714 
          self.key = iprot.readString();
7715 
        else:
7716 
          iprot.skip(ftype)
7717 
      elif fid == 2:
7718 
        if ftype == TType.STRUCT:
7719 
          self.vendorItemMapping = VendorItemMapping()
7720 
          self.vendorItemMapping.read(iprot)
7721 
        else:
7722 
          iprot.skip(ftype)
7723 
      else:
7724 
        iprot.skip(ftype)
7725 
      iprot.readFieldEnd()
7726 
    iprot.readStructEnd()
7727 
 
7728 
  def write(self, oprot):
7729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7731 
      return
7732 
    oprot.writeStructBegin('addVendorItemMapping_args')
7733 
    if self.key is not None:
7734 
      oprot.writeFieldBegin('key', TType.STRING, 1)
7735 
      oprot.writeString(self.key)
7736 
      oprot.writeFieldEnd()
7737 
    if self.vendorItemMapping is not None:
7738 
      oprot.writeFieldBegin('vendorItemMapping', TType.STRUCT, 2)
7739 
      self.vendorItemMapping.write(oprot)
7740 
      oprot.writeFieldEnd()
7741 
    oprot.writeFieldStop()
7742 
    oprot.writeStructEnd()
7743 
 
7744 
  def validate(self):
7745 
    return
7746 
 
7747 
 
7748 
  def __repr__(self):
7749 
    L = ['%s=%r' % (key, value)
7750 
      for key, value in self.__dict__.iteritems()]
7751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7752 
 
7753 
  def __eq__(self, other):
7754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7755 
 
7756 
  def __ne__(self, other):
7757 
    return not (self == other)
7758 
 
7759 
class addVendorItemMapping_result:
7760 
  """
7761 
  Attributes:
7762 
   - cex
7763 
  """
7764 
 
7765 
  thrift_spec = (
7766 
    None, # 0
7767 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
7768 
  )
7769 
 
7770 
  def __init__(self, cex=None,):
7771 
    self.cex = cex
7772 
 
7773 
  def read(self, iprot):
7774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7776 
      return
7777 
    iprot.readStructBegin()
7778 
    while True:
7779 
      (fname, ftype, fid) = iprot.readFieldBegin()
7780 
      if ftype == TType.STOP:
7781 
        break
7782 
      if fid == 1:
7783 
        if ftype == TType.STRUCT:
7784 
          self.cex = InventoryServiceException()
7785 
          self.cex.read(iprot)
7786 
        else:
7787 
          iprot.skip(ftype)
7788 
      else:
7789 
        iprot.skip(ftype)
7790 
      iprot.readFieldEnd()
7791 
    iprot.readStructEnd()
7792 
 
7793 
  def write(self, oprot):
7794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7796 
      return
7797 
    oprot.writeStructBegin('addVendorItemMapping_result')
7798 
    if self.cex is not None:
7799 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7800 
      self.cex.write(oprot)
7801 
      oprot.writeFieldEnd()
7802 
    oprot.writeFieldStop()
7803 
    oprot.writeStructEnd()
7804 
 
7805 
  def validate(self):
7806 
    return
7807 
 
7808 
 
7809 
  def __repr__(self):
7810 
    L = ['%s=%r' % (key, value)
7811 
      for key, value in self.__dict__.iteritems()]
7812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7813 
 
7814 
  def __eq__(self, other):
7815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7816 
 
7817 
  def __ne__(self, other):
7818 
    return not (self == other)
7819 
 
7820 
class getVendorItemMappings_args:
7821 
  """
7822 
  Attributes:
7823 
   - itemId
7824 
  """
7825 
 
7826 
  thrift_spec = (
7827 
    None, # 0
7828 
    (1, TType.I64, 'itemId', None, None, ), # 1
7829 
  )
7830 
 
7831 
  def __init__(self, itemId=None,):
7832 
    self.itemId = itemId
7833 
 
7834 
  def read(self, iprot):
7835 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7836 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7837 
      return
7838 
    iprot.readStructBegin()
7839 
    while True:
7840 
      (fname, ftype, fid) = iprot.readFieldBegin()
7841 
      if ftype == TType.STOP:
7842 
        break
7843 
      if fid == 1:
7844 
        if ftype == TType.I64:
7845 
          self.itemId = iprot.readI64();
7846 
        else:
7847 
          iprot.skip(ftype)
7848 
      else:
7849 
        iprot.skip(ftype)
7850 
      iprot.readFieldEnd()
7851 
    iprot.readStructEnd()
7852 
 
7853 
  def write(self, oprot):
7854 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7855 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7856 
      return
7857 
    oprot.writeStructBegin('getVendorItemMappings_args')
7858 
    if self.itemId is not None:
7859 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
7860 
      oprot.writeI64(self.itemId)
7861 
      oprot.writeFieldEnd()
7862 
    oprot.writeFieldStop()
7863 
    oprot.writeStructEnd()
7864 
 
7865 
  def validate(self):
7866 
    return
7867 
 
7868 
 
7869 
  def __repr__(self):
7870 
    L = ['%s=%r' % (key, value)
7871 
      for key, value in self.__dict__.iteritems()]
7872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7873 
 
7874 
  def __eq__(self, other):
7875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7876 
 
7877 
  def __ne__(self, other):
7878 
    return not (self == other)
7879 
 
7880 
class getVendorItemMappings_result:
7881 
  """
7882 
  Attributes:
7883 
   - success
7884 
   - cex
7885 
  """
7886 
 
7887 
  thrift_spec = (
7888 
    (0, TType.LIST, 'success', (TType.STRUCT,(VendorItemMapping, VendorItemMapping.thrift_spec)), None, ), # 0
7889 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
7890 
  )
7891 
 
7892 
  def __init__(self, success=None, cex=None,):
7893 
    self.success = success
7894 
    self.cex = cex
7895 
 
7896 
  def read(self, iprot):
7897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7899 
      return
7900 
    iprot.readStructBegin()
7901 
    while True:
7902 
      (fname, ftype, fid) = iprot.readFieldBegin()
7903 
      if ftype == TType.STOP:
7904 
        break
7905 
      if fid == 0:
7906 
        if ftype == TType.LIST:
7907 
          self.success = []
8182 amar.kumar 7908 
          (_etype83, _size80) = iprot.readListBegin()
7909 
          for _i84 in xrange(_size80):
7910 
            _elem85 = VendorItemMapping()
7911 
            _elem85.read(iprot)
7912 
            self.success.append(_elem85)
5944 mandeep.dh 7913 
          iprot.readListEnd()
7914 
        else:
7915 
          iprot.skip(ftype)
7916 
      elif fid == 1:
7917 
        if ftype == TType.STRUCT:
7918 
          self.cex = InventoryServiceException()
7919 
          self.cex.read(iprot)
7920 
        else:
7921 
          iprot.skip(ftype)
7922 
      else:
7923 
        iprot.skip(ftype)
7924 
      iprot.readFieldEnd()
7925 
    iprot.readStructEnd()
7926 
 
7927 
  def write(self, oprot):
7928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7930 
      return
7931 
    oprot.writeStructBegin('getVendorItemMappings_result')
7932 
    if self.success is not None:
7933 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7934 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 7935 
      for iter86 in self.success:
7936 
        iter86.write(oprot)
5944 mandeep.dh 7937 
      oprot.writeListEnd()
7938 
      oprot.writeFieldEnd()
7939 
    if self.cex is not None:
7940 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7941 
      self.cex.write(oprot)
7942 
      oprot.writeFieldEnd()
7943 
    oprot.writeFieldStop()
7944 
    oprot.writeStructEnd()
7945 
 
7946 
  def validate(self):
7947 
    return
7948 
 
7949 
 
7950 
  def __repr__(self):
7951 
    L = ['%s=%r' % (key, value)
7952 
      for key, value in self.__dict__.iteritems()]
7953 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7954 
 
7955 
  def __eq__(self, other):
7956 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7957 
 
7958 
  def __ne__(self, other):
7959 
    return not (self == other)
7960 
 
7961 
class getPendingOrdersInventory_args:
7962 
  """
7963 
  Attributes:
7964 
   - vendorid
7965 
  """
7966 
 
7967 
  thrift_spec = (
7968 
    None, # 0
7969 
    (1, TType.I64, 'vendorid', None, None, ), # 1
7970 
  )
7971 
 
7972 
  def __init__(self, vendorid=None,):
7973 
    self.vendorid = vendorid
7974 
 
7975 
  def read(self, iprot):
7976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7978 
      return
7979 
    iprot.readStructBegin()
7980 
    while True:
7981 
      (fname, ftype, fid) = iprot.readFieldBegin()
7982 
      if ftype == TType.STOP:
7983 
        break
7984 
      if fid == 1:
7985 
        if ftype == TType.I64:
7986 
          self.vendorid = iprot.readI64();
7987 
        else:
7988 
          iprot.skip(ftype)
7989 
      else:
7990 
        iprot.skip(ftype)
7991 
      iprot.readFieldEnd()
7992 
    iprot.readStructEnd()
7993 
 
7994 
  def write(self, oprot):
7995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7997 
      return
7998 
    oprot.writeStructBegin('getPendingOrdersInventory_args')
7999 
    if self.vendorid is not None:
8000 
      oprot.writeFieldBegin('vendorid', TType.I64, 1)
8001 
      oprot.writeI64(self.vendorid)
8002 
      oprot.writeFieldEnd()
8003 
    oprot.writeFieldStop()
8004 
    oprot.writeStructEnd()
8005 
 
8006 
  def validate(self):
8007 
    return
8008 
 
8009 
 
8010 
  def __repr__(self):
8011 
    L = ['%s=%r' % (key, value)
8012 
      for key, value in self.__dict__.iteritems()]
8013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8014 
 
8015 
  def __eq__(self, other):
8016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8017 
 
8018 
  def __ne__(self, other):
8019 
    return not (self == other)
8020 
 
8021 
class getPendingOrdersInventory_result:
8022 
  """
8023 
  Attributes:
8024 
   - success
8025 
  """
8026 
 
8027 
  thrift_spec = (
8028 
    (0, TType.LIST, 'success', (TType.STRUCT,(AvailableAndReservedStock, AvailableAndReservedStock.thrift_spec)), None, ), # 0
8029 
  )
8030 
 
8031 
  def __init__(self, success=None,):
8032 
    self.success = success
8033 
 
8034 
  def read(self, iprot):
8035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8037 
      return
8038 
    iprot.readStructBegin()
8039 
    while True:
8040 
      (fname, ftype, fid) = iprot.readFieldBegin()
8041 
      if ftype == TType.STOP:
8042 
        break
8043 
      if fid == 0:
8044 
        if ftype == TType.LIST:
8045 
          self.success = []
8182 amar.kumar 8046 
          (_etype90, _size87) = iprot.readListBegin()
8047 
          for _i91 in xrange(_size87):
8048 
            _elem92 = AvailableAndReservedStock()
8049 
            _elem92.read(iprot)
8050 
            self.success.append(_elem92)
5944 mandeep.dh 8051 
          iprot.readListEnd()
8052 
        else:
8053 
          iprot.skip(ftype)
8054 
      else:
8055 
        iprot.skip(ftype)
8056 
      iprot.readFieldEnd()
8057 
    iprot.readStructEnd()
8058 
 
8059 
  def write(self, oprot):
8060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8062 
      return
8063 
    oprot.writeStructBegin('getPendingOrdersInventory_result')
8064 
    if self.success is not None:
8065 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8066 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 8067 
      for iter93 in self.success:
8068 
        iter93.write(oprot)
5944 mandeep.dh 8069 
      oprot.writeListEnd()
8070 
      oprot.writeFieldEnd()
8071 
    oprot.writeFieldStop()
8072 
    oprot.writeStructEnd()
8073 
 
8074 
  def validate(self):
8075 
    return
8076 
 
8077 
 
8078 
  def __repr__(self):
8079 
    L = ['%s=%r' % (key, value)
8080 
      for key, value in self.__dict__.iteritems()]
8081 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8082 
 
8083 
  def __eq__(self, other):
8084 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8085 
 
8086 
  def __ne__(self, other):
8087 
    return not (self == other)
8088 
 
8089 
class getWarehouses_args:
8090 
  """
8091 
  Attributes:
8092 
   - warehouseType
8093 
   - inventoryType
8094 
   - vendorId
8095 
   - billingWarehouseId
8096 
   - shippingWarehouseId
8097 
  """
8098 
 
8099 
  thrift_spec = (
8100 
    None, # 0
8101 
    (1, TType.I32, 'warehouseType', None, None, ), # 1
8102 
    (2, TType.I32, 'inventoryType', None, None, ), # 2
8103 
    (3, TType.I64, 'vendorId', None, None, ), # 3
8104 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
8105 
    (5, TType.I64, 'shippingWarehouseId', None, None, ), # 5
8106 
  )
8107 
 
8108 
  def __init__(self, warehouseType=None, inventoryType=None, vendorId=None, billingWarehouseId=None, shippingWarehouseId=None,):
8109 
    self.warehouseType = warehouseType
8110 
    self.inventoryType = inventoryType
8111 
    self.vendorId = vendorId
8112 
    self.billingWarehouseId = billingWarehouseId
8113 
    self.shippingWarehouseId = shippingWarehouseId
8114 
 
8115 
  def read(self, iprot):
8116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8118 
      return
8119 
    iprot.readStructBegin()
8120 
    while True:
8121 
      (fname, ftype, fid) = iprot.readFieldBegin()
8122 
      if ftype == TType.STOP:
8123 
        break
8124 
      if fid == 1:
8125 
        if ftype == TType.I32:
8126 
          self.warehouseType = iprot.readI32();
8127 
        else:
8128 
          iprot.skip(ftype)
8129 
      elif fid == 2:
8130 
        if ftype == TType.I32:
8131 
          self.inventoryType = iprot.readI32();
8132 
        else:
8133 
          iprot.skip(ftype)
8134 
      elif fid == 3:
8135 
        if ftype == TType.I64:
8136 
          self.vendorId = iprot.readI64();
8137 
        else:
8138 
          iprot.skip(ftype)
8139 
      elif fid == 4:
8140 
        if ftype == TType.I64:
8141 
          self.billingWarehouseId = iprot.readI64();
8142 
        else:
8143 
          iprot.skip(ftype)
8144 
      elif fid == 5:
8145 
        if ftype == TType.I64:
8146 
          self.shippingWarehouseId = iprot.readI64();
8147 
        else:
8148 
          iprot.skip(ftype)
8149 
      else:
8150 
        iprot.skip(ftype)
8151 
      iprot.readFieldEnd()
8152 
    iprot.readStructEnd()
8153 
 
8154 
  def write(self, oprot):
8155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8157 
      return
8158 
    oprot.writeStructBegin('getWarehouses_args')
8159 
    if self.warehouseType is not None:
8160 
      oprot.writeFieldBegin('warehouseType', TType.I32, 1)
8161 
      oprot.writeI32(self.warehouseType)
8162 
      oprot.writeFieldEnd()
8163 
    if self.inventoryType is not None:
8164 
      oprot.writeFieldBegin('inventoryType', TType.I32, 2)
8165 
      oprot.writeI32(self.inventoryType)
8166 
      oprot.writeFieldEnd()
8167 
    if self.vendorId is not None:
8168 
      oprot.writeFieldBegin('vendorId', TType.I64, 3)
8169 
      oprot.writeI64(self.vendorId)
8170 
      oprot.writeFieldEnd()
8171 
    if self.billingWarehouseId is not None:
8172 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
8173 
      oprot.writeI64(self.billingWarehouseId)
8174 
      oprot.writeFieldEnd()
8175 
    if self.shippingWarehouseId is not None:
8176 
      oprot.writeFieldBegin('shippingWarehouseId', TType.I64, 5)
8177 
      oprot.writeI64(self.shippingWarehouseId)
8178 
      oprot.writeFieldEnd()
8179 
    oprot.writeFieldStop()
8180 
    oprot.writeStructEnd()
8181 
 
8182 
  def validate(self):
8183 
    return
8184 
 
8185 
 
8186 
  def __repr__(self):
8187 
    L = ['%s=%r' % (key, value)
8188 
      for key, value in self.__dict__.iteritems()]
8189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8190 
 
8191 
  def __eq__(self, other):
8192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8193 
 
8194 
  def __ne__(self, other):
8195 
    return not (self == other)
8196 
 
8197 
class getWarehouses_result:
8198 
  """
8199 
  Attributes:
8200 
   - success
8201 
  """
8202 
 
8203 
  thrift_spec = (
8204 
    (0, TType.LIST, 'success', (TType.STRUCT,(Warehouse, Warehouse.thrift_spec)), None, ), # 0
8205 
  )
8206 
 
8207 
  def __init__(self, success=None,):
8208 
    self.success = success
8209 
 
8210 
  def read(self, iprot):
8211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8213 
      return
8214 
    iprot.readStructBegin()
8215 
    while True:
8216 
      (fname, ftype, fid) = iprot.readFieldBegin()
8217 
      if ftype == TType.STOP:
8218 
        break
8219 
      if fid == 0:
8220 
        if ftype == TType.LIST:
8221 
          self.success = []
8182 amar.kumar 8222 
          (_etype97, _size94) = iprot.readListBegin()
8223 
          for _i98 in xrange(_size94):
8224 
            _elem99 = Warehouse()
8225 
            _elem99.read(iprot)
8226 
            self.success.append(_elem99)
5944 mandeep.dh 8227 
          iprot.readListEnd()
8228 
        else:
8229 
          iprot.skip(ftype)
8230 
      else:
8231 
        iprot.skip(ftype)
8232 
      iprot.readFieldEnd()
8233 
    iprot.readStructEnd()
8234 
 
8235 
  def write(self, oprot):
8236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8238 
      return
8239 
    oprot.writeStructBegin('getWarehouses_result')
8240 
    if self.success is not None:
8241 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8242 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 8243 
      for iter100 in self.success:
8244 
        iter100.write(oprot)
5944 mandeep.dh 8245 
      oprot.writeListEnd()
8246 
      oprot.writeFieldEnd()
8247 
    oprot.writeFieldStop()
8248 
    oprot.writeStructEnd()
8249 
 
8250 
  def validate(self):
8251 
    return
8252 
 
8253 
 
8254 
  def __repr__(self):
8255 
    L = ['%s=%r' % (key, value)
8256 
      for key, value in self.__dict__.iteritems()]
8257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8258 
 
8259 
  def __eq__(self, other):
8260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8261 
 
8262 
  def __ne__(self, other):
8263 
    return not (self == other)
8264 
 
8265 
class resetAvailability_args:
8266 
  """
8267 
  Attributes:
8268 
   - itemKey
8269 
   - vendorId
8270 
   - quantity
8271 
   - warehouseId
8272 
  """
8273 
 
8274 
  thrift_spec = (
8275 
    None, # 0
8276 
    (1, TType.STRING, 'itemKey', None, None, ), # 1
8277 
    (2, TType.I64, 'vendorId', None, None, ), # 2
8278 
    (3, TType.I64, 'quantity', None, None, ), # 3
8279 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
8280 
  )
8281 
 
8282 
  def __init__(self, itemKey=None, vendorId=None, quantity=None, warehouseId=None,):
8283 
    self.itemKey = itemKey
8284 
    self.vendorId = vendorId
8285 
    self.quantity = quantity
8286 
    self.warehouseId = warehouseId
8287 
 
8288 
  def read(self, iprot):
8289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8291 
      return
8292 
    iprot.readStructBegin()
8293 
    while True:
8294 
      (fname, ftype, fid) = iprot.readFieldBegin()
8295 
      if ftype == TType.STOP:
8296 
        break
8297 
      if fid == 1:
8298 
        if ftype == TType.STRING:
8299 
          self.itemKey = iprot.readString();
8300 
        else:
8301 
          iprot.skip(ftype)
8302 
      elif fid == 2:
8303 
        if ftype == TType.I64:
8304 
          self.vendorId = iprot.readI64();
8305 
        else:
8306 
          iprot.skip(ftype)
8307 
      elif fid == 3:
8308 
        if ftype == TType.I64:
8309 
          self.quantity = iprot.readI64();
8310 
        else:
8311 
          iprot.skip(ftype)
8312 
      elif fid == 4:
8313 
        if ftype == TType.I64:
8314 
          self.warehouseId = iprot.readI64();
8315 
        else:
8316 
          iprot.skip(ftype)
8317 
      else:
8318 
        iprot.skip(ftype)
8319 
      iprot.readFieldEnd()
8320 
    iprot.readStructEnd()
8321 
 
8322 
  def write(self, oprot):
8323 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8324 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8325 
      return
8326 
    oprot.writeStructBegin('resetAvailability_args')
8327 
    if self.itemKey is not None:
8328 
      oprot.writeFieldBegin('itemKey', TType.STRING, 1)
8329 
      oprot.writeString(self.itemKey)
8330 
      oprot.writeFieldEnd()
8331 
    if self.vendorId is not None:
8332 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
8333 
      oprot.writeI64(self.vendorId)
8334 
      oprot.writeFieldEnd()
8335 
    if self.quantity is not None:
8336 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
8337 
      oprot.writeI64(self.quantity)
8338 
      oprot.writeFieldEnd()
8339 
    if self.warehouseId is not None:
8340 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
8341 
      oprot.writeI64(self.warehouseId)
8342 
      oprot.writeFieldEnd()
8343 
    oprot.writeFieldStop()
8344 
    oprot.writeStructEnd()
8345 
 
8346 
  def validate(self):
8347 
    return
8348 
 
8349 
 
8350 
  def __repr__(self):
8351 
    L = ['%s=%r' % (key, value)
8352 
      for key, value in self.__dict__.iteritems()]
8353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8354 
 
8355 
  def __eq__(self, other):
8356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8357 
 
8358 
  def __ne__(self, other):
8359 
    return not (self == other)
8360 
 
8361 
class resetAvailability_result:
8362 
  """
8363 
  Attributes:
8364 
   - cex
8365 
  """
8366 
 
8367 
  thrift_spec = (
8368 
    None, # 0
8369 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
8370 
  )
8371 
 
8372 
  def __init__(self, cex=None,):
8373 
    self.cex = cex
8374 
 
8375 
  def read(self, iprot):
8376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8378 
      return
8379 
    iprot.readStructBegin()
8380 
    while True:
8381 
      (fname, ftype, fid) = iprot.readFieldBegin()
8382 
      if ftype == TType.STOP:
8383 
        break
8384 
      if fid == 1:
8385 
        if ftype == TType.STRUCT:
8386 
          self.cex = InventoryServiceException()
8387 
          self.cex.read(iprot)
8388 
        else:
8389 
          iprot.skip(ftype)
8390 
      else:
8391 
        iprot.skip(ftype)
8392 
      iprot.readFieldEnd()
8393 
    iprot.readStructEnd()
8394 
 
8395 
  def write(self, oprot):
8396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8398 
      return
8399 
    oprot.writeStructBegin('resetAvailability_result')
8400 
    if self.cex is not None:
8401 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8402 
      self.cex.write(oprot)
8403 
      oprot.writeFieldEnd()
8404 
    oprot.writeFieldStop()
8405 
    oprot.writeStructEnd()
8406 
 
8407 
  def validate(self):
8408 
    return
8409 
 
8410 
 
8411 
  def __repr__(self):
8412 
    L = ['%s=%r' % (key, value)
8413 
      for key, value in self.__dict__.iteritems()]
8414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8415 
 
8416 
  def __eq__(self, other):
8417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8418 
 
8419 
  def __ne__(self, other):
8420 
    return not (self == other)
8421 
 
8422 
class resetAvailabilityForWarehouse_args:
8423 
  """
8424 
  Attributes:
8425 
   - warehouseId
8426 
  """
8427 
 
8428 
  thrift_spec = (
8429 
    None, # 0
8430 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8431 
  )
8432 
 
8433 
  def __init__(self, warehouseId=None,):
8434 
    self.warehouseId = warehouseId
8435 
 
8436 
  def read(self, iprot):
8437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8439 
      return
8440 
    iprot.readStructBegin()
8441 
    while True:
8442 
      (fname, ftype, fid) = iprot.readFieldBegin()
8443 
      if ftype == TType.STOP:
8444 
        break
8445 
      if fid == 1:
8446 
        if ftype == TType.I64:
8447 
          self.warehouseId = iprot.readI64();
8448 
        else:
8449 
          iprot.skip(ftype)
8450 
      else:
8451 
        iprot.skip(ftype)
8452 
      iprot.readFieldEnd()
8453 
    iprot.readStructEnd()
8454 
 
8455 
  def write(self, oprot):
8456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8458 
      return
8459 
    oprot.writeStructBegin('resetAvailabilityForWarehouse_args')
8460 
    if self.warehouseId is not None:
8461 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8462 
      oprot.writeI64(self.warehouseId)
8463 
      oprot.writeFieldEnd()
8464 
    oprot.writeFieldStop()
8465 
    oprot.writeStructEnd()
8466 
 
8467 
  def validate(self):
8468 
    return
8469 
 
8470 
 
8471 
  def __repr__(self):
8472 
    L = ['%s=%r' % (key, value)
8473 
      for key, value in self.__dict__.iteritems()]
8474 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8475 
 
8476 
  def __eq__(self, other):
8477 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8478 
 
8479 
  def __ne__(self, other):
8480 
    return not (self == other)
8481 
 
8482 
class resetAvailabilityForWarehouse_result:
8483 
  """
8484 
  Attributes:
8485 
   - cex
8486 
  """
8487 
 
8488 
  thrift_spec = (
8489 
    None, # 0
8490 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
8491 
  )
8492 
 
8493 
  def __init__(self, cex=None,):
8494 
    self.cex = cex
8495 
 
8496 
  def read(self, iprot):
8497 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8498 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8499 
      return
8500 
    iprot.readStructBegin()
8501 
    while True:
8502 
      (fname, ftype, fid) = iprot.readFieldBegin()
8503 
      if ftype == TType.STOP:
8504 
        break
8505 
      if fid == 1:
8506 
        if ftype == TType.STRUCT:
8507 
          self.cex = InventoryServiceException()
8508 
          self.cex.read(iprot)
8509 
        else:
8510 
          iprot.skip(ftype)
8511 
      else:
8512 
        iprot.skip(ftype)
8513 
      iprot.readFieldEnd()
8514 
    iprot.readStructEnd()
8515 
 
8516 
  def write(self, oprot):
8517 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8518 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8519 
      return
8520 
    oprot.writeStructBegin('resetAvailabilityForWarehouse_result')
8521 
    if self.cex is not None:
8522 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8523 
      self.cex.write(oprot)
8524 
      oprot.writeFieldEnd()
8525 
    oprot.writeFieldStop()
8526 
    oprot.writeStructEnd()
8527 
 
8528 
  def validate(self):
8529 
    return
8530 
 
8531 
 
8532 
  def __repr__(self):
8533 
    L = ['%s=%r' % (key, value)
8534 
      for key, value in self.__dict__.iteritems()]
8535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8536 
 
8537 
  def __eq__(self, other):
8538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8539 
 
8540 
  def __ne__(self, other):
8541 
    return not (self == other)
8542 
 
8543 
class getItemKeysToBeProcessed_args:
8544 
  """
8545 
  Attributes:
8546 
   - warehouseId
8547 
  """
8548 
 
8549 
  thrift_spec = (
8550 
    None, # 0
8551 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8552 
  )
8553 
 
8554 
  def __init__(self, warehouseId=None,):
8555 
    self.warehouseId = warehouseId
8556 
 
8557 
  def read(self, iprot):
8558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8560 
      return
8561 
    iprot.readStructBegin()
8562 
    while True:
8563 
      (fname, ftype, fid) = iprot.readFieldBegin()
8564 
      if ftype == TType.STOP:
8565 
        break
8566 
      if fid == 1:
8567 
        if ftype == TType.I64:
8568 
          self.warehouseId = iprot.readI64();
8569 
        else:
8570 
          iprot.skip(ftype)
8571 
      else:
8572 
        iprot.skip(ftype)
8573 
      iprot.readFieldEnd()
8574 
    iprot.readStructEnd()
8575 
 
8576 
  def write(self, oprot):
8577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8579 
      return
8580 
    oprot.writeStructBegin('getItemKeysToBeProcessed_args')
8581 
    if self.warehouseId is not None:
8582 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8583 
      oprot.writeI64(self.warehouseId)
8584 
      oprot.writeFieldEnd()
8585 
    oprot.writeFieldStop()
8586 
    oprot.writeStructEnd()
8587 
 
8588 
  def validate(self):
8589 
    return
8590 
 
8591 
 
8592 
  def __repr__(self):
8593 
    L = ['%s=%r' % (key, value)
8594 
      for key, value in self.__dict__.iteritems()]
8595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8596 
 
8597 
  def __eq__(self, other):
8598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8599 
 
8600 
  def __ne__(self, other):
8601 
    return not (self == other)
8602 
 
8603 
class getItemKeysToBeProcessed_result:
8604 
  """
8605 
  Attributes:
8606 
   - success
8607 
  """
8608 
 
8609 
  thrift_spec = (
8610 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
8611 
  )
8612 
 
8613 
  def __init__(self, success=None,):
8614 
    self.success = success
8615 
 
8616 
  def read(self, iprot):
8617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8619 
      return
8620 
    iprot.readStructBegin()
8621 
    while True:
8622 
      (fname, ftype, fid) = iprot.readFieldBegin()
8623 
      if ftype == TType.STOP:
8624 
        break
8625 
      if fid == 0:
8626 
        if ftype == TType.LIST:
8627 
          self.success = []
8182 amar.kumar 8628 
          (_etype104, _size101) = iprot.readListBegin()
8629 
          for _i105 in xrange(_size101):
8630 
            _elem106 = iprot.readString();
8631 
            self.success.append(_elem106)
5944 mandeep.dh 8632 
          iprot.readListEnd()
8633 
        else:
8634 
          iprot.skip(ftype)
8635 
      else:
8636 
        iprot.skip(ftype)
8637 
      iprot.readFieldEnd()
8638 
    iprot.readStructEnd()
8639 
 
8640 
  def write(self, oprot):
8641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8643 
      return
8644 
    oprot.writeStructBegin('getItemKeysToBeProcessed_result')
8645 
    if self.success is not None:
8646 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8647 
      oprot.writeListBegin(TType.STRING, len(self.success))
8182 amar.kumar 8648 
      for iter107 in self.success:
8649 
        oprot.writeString(iter107)
5944 mandeep.dh 8650 
      oprot.writeListEnd()
8651 
      oprot.writeFieldEnd()
8652 
    oprot.writeFieldStop()
8653 
    oprot.writeStructEnd()
8654 
 
8655 
  def validate(self):
8656 
    return
8657 
 
8658 
 
8659 
  def __repr__(self):
8660 
    L = ['%s=%r' % (key, value)
8661 
      for key, value in self.__dict__.iteritems()]
8662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8663 
 
8664 
  def __eq__(self, other):
8665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8666 
 
8667 
  def __ne__(self, other):
8668 
    return not (self == other)
8669 
 
8670 
class markMissedInventoryUpdatesAsProcessed_args:
8671 
  """
8672 
  Attributes:
8673 
   - itemKey
8674 
   - warehouseId
8675 
  """
8676 
 
8677 
  thrift_spec = (
8678 
    None, # 0
8679 
    (1, TType.STRING, 'itemKey', None, None, ), # 1
8680 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8681 
  )
8682 
 
8683 
  def __init__(self, itemKey=None, warehouseId=None,):
8684 
    self.itemKey = itemKey
8685 
    self.warehouseId = warehouseId
8686 
 
8687 
  def read(self, iprot):
8688 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8689 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8690 
      return
8691 
    iprot.readStructBegin()
8692 
    while True:
8693 
      (fname, ftype, fid) = iprot.readFieldBegin()
8694 
      if ftype == TType.STOP:
8695 
        break
8696 
      if fid == 1:
8697 
        if ftype == TType.STRING:
8698 
          self.itemKey = iprot.readString();
8699 
        else:
8700 
          iprot.skip(ftype)
8701 
      elif fid == 2:
8702 
        if ftype == TType.I64:
8703 
          self.warehouseId = iprot.readI64();
8704 
        else:
8705 
          iprot.skip(ftype)
8706 
      else:
8707 
        iprot.skip(ftype)
8708 
      iprot.readFieldEnd()
8709 
    iprot.readStructEnd()
8710 
 
8711 
  def write(self, oprot):
8712 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8713 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8714 
      return
8715 
    oprot.writeStructBegin('markMissedInventoryUpdatesAsProcessed_args')
8716 
    if self.itemKey is not None:
8717 
      oprot.writeFieldBegin('itemKey', TType.STRING, 1)
8718 
      oprot.writeString(self.itemKey)
8719 
      oprot.writeFieldEnd()
8720 
    if self.warehouseId is not None:
8721 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8722 
      oprot.writeI64(self.warehouseId)
8723 
      oprot.writeFieldEnd()
8724 
    oprot.writeFieldStop()
8725 
    oprot.writeStructEnd()
8726 
 
8727 
  def validate(self):
8728 
    return
8729 
 
8730 
 
8731 
  def __repr__(self):
8732 
    L = ['%s=%r' % (key, value)
8733 
      for key, value in self.__dict__.iteritems()]
8734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8735 
 
8736 
  def __eq__(self, other):
8737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8738 
 
8739 
  def __ne__(self, other):
8740 
    return not (self == other)
8741 
 
8742 
class markMissedInventoryUpdatesAsProcessed_result:
8743 
 
8744 
  thrift_spec = (
8745 
  )
8746 
 
8747 
  def read(self, iprot):
8748 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8749 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8750 
      return
8751 
    iprot.readStructBegin()
8752 
    while True:
8753 
      (fname, ftype, fid) = iprot.readFieldBegin()
8754 
      if ftype == TType.STOP:
8755 
        break
8756 
      else:
8757 
        iprot.skip(ftype)
8758 
      iprot.readFieldEnd()
8759 
    iprot.readStructEnd()
8760 
 
8761 
  def write(self, oprot):
8762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8764 
      return
8765 
    oprot.writeStructBegin('markMissedInventoryUpdatesAsProcessed_result')
8766 
    oprot.writeFieldStop()
8767 
    oprot.writeStructEnd()
8768 
 
8769 
  def validate(self):
8770 
    return
8771 
 
8772 
 
8773 
  def __repr__(self):
8774 
    L = ['%s=%r' % (key, value)
8775 
      for key, value in self.__dict__.iteritems()]
8776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8777 
 
8778 
  def __eq__(self, other):
8779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8780 
 
8781 
  def __ne__(self, other):
8782 
    return not (self == other)
8783 
 
8784 
class getIgnoredItemKeys_args:
8785 
 
8786 
  thrift_spec = (
8787 
  )
8788 
 
8789 
  def read(self, iprot):
8790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8792 
      return
8793 
    iprot.readStructBegin()
8794 
    while True:
8795 
      (fname, ftype, fid) = iprot.readFieldBegin()
8796 
      if ftype == TType.STOP:
8797 
        break
8798 
      else:
8799 
        iprot.skip(ftype)
8800 
      iprot.readFieldEnd()
8801 
    iprot.readStructEnd()
8802 
 
8803 
  def write(self, oprot):
8804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8806 
      return
8807 
    oprot.writeStructBegin('getIgnoredItemKeys_args')
8808 
    oprot.writeFieldStop()
8809 
    oprot.writeStructEnd()
8810 
 
8811 
  def validate(self):
8812 
    return
8813 
 
8814 
 
8815 
  def __repr__(self):
8816 
    L = ['%s=%r' % (key, value)
8817 
      for key, value in self.__dict__.iteritems()]
8818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8819 
 
8820 
  def __eq__(self, other):
8821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8822 
 
8823 
  def __ne__(self, other):
8824 
    return not (self == other)
8825 
 
8826 
class getIgnoredItemKeys_result:
8827 
  """
8828 
  Attributes:
8829 
   - success
8830 
  """
8831 
 
8832 
  thrift_spec = (
8833 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.MAP,(TType.I64,None,TType.I64,None)), None, ), # 0
8834 
  )
8835 
 
8836 
  def __init__(self, success=None,):
8837 
    self.success = success
8838 
 
8839 
  def read(self, iprot):
8840 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8841 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8842 
      return
8843 
    iprot.readStructBegin()
8844 
    while True:
8845 
      (fname, ftype, fid) = iprot.readFieldBegin()
8846 
      if ftype == TType.STOP:
8847 
        break
8848 
      if fid == 0:
8849 
        if ftype == TType.MAP:
8850 
          self.success = {}
8182 amar.kumar 8851 
          (_ktype109, _vtype110, _size108 ) = iprot.readMapBegin()
8852 
          for _i112 in xrange(_size108):
8853 
            _key113 = iprot.readString();
8854 
            _val114 = {}
8855 
            (_ktype116, _vtype117, _size115 ) = iprot.readMapBegin()
8856 
            for _i119 in xrange(_size115):
8857 
              _key120 = iprot.readI64();
8858 
              _val121 = iprot.readI64();
8859 
              _val114[_key120] = _val121
5944 mandeep.dh 8860 
            iprot.readMapEnd()
8182 amar.kumar 8861 
            self.success[_key113] = _val114
5944 mandeep.dh 8862 
          iprot.readMapEnd()
8863 
        else:
8864 
          iprot.skip(ftype)
8865 
      else:
8866 
        iprot.skip(ftype)
8867 
      iprot.readFieldEnd()
8868 
    iprot.readStructEnd()
8869 
 
8870 
  def write(self, oprot):
8871 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8872 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8873 
      return
8874 
    oprot.writeStructBegin('getIgnoredItemKeys_result')
8875 
    if self.success is not None:
8876 
      oprot.writeFieldBegin('success', TType.MAP, 0)
8877 
      oprot.writeMapBegin(TType.STRING, TType.MAP, len(self.success))
8182 amar.kumar 8878 
      for kiter122,viter123 in self.success.items():
8879 
        oprot.writeString(kiter122)
8880 
        oprot.writeMapBegin(TType.I64, TType.I64, len(viter123))
8881 
        for kiter124,viter125 in viter123.items():
8882 
          oprot.writeI64(kiter124)
8883 
          oprot.writeI64(viter125)
5944 mandeep.dh 8884 
        oprot.writeMapEnd()
8885 
      oprot.writeMapEnd()
8886 
      oprot.writeFieldEnd()
8887 
    oprot.writeFieldStop()
8888 
    oprot.writeStructEnd()
8889 
 
8890 
  def validate(self):
8891 
    return
8892 
 
8893 
 
8894 
  def __repr__(self):
8895 
    L = ['%s=%r' % (key, value)
8896 
      for key, value in self.__dict__.iteritems()]
8897 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8898 
 
8899 
  def __eq__(self, other):
8900 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8901 
 
8902 
  def __ne__(self, other):
8903 
    return not (self == other)
8904 
 
8905 
class addBadInventory_args:
8906 
  """
8907 
  Attributes:
8908 
   - itemId
8909 
   - warehouseId
8910 
   - quantity
8911 
  """
8912 
 
8913 
  thrift_spec = (
8914 
    None, # 0
8915 
    (1, TType.I64, 'itemId', None, None, ), # 1
8916 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8917 
    (3, TType.I64, 'quantity', None, None, ), # 3
8918 
  )
8919 
 
8920 
  def __init__(self, itemId=None, warehouseId=None, quantity=None,):
8921 
    self.itemId = itemId
8922 
    self.warehouseId = warehouseId
8923 
    self.quantity = quantity
8924 
 
8925 
  def read(self, iprot):
8926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8928 
      return
8929 
    iprot.readStructBegin()
8930 
    while True:
8931 
      (fname, ftype, fid) = iprot.readFieldBegin()
8932 
      if ftype == TType.STOP:
8933 
        break
8934 
      if fid == 1:
8935 
        if ftype == TType.I64:
8936 
          self.itemId = iprot.readI64();
8937 
        else:
8938 
          iprot.skip(ftype)
8939 
      elif fid == 2:
8940 
        if ftype == TType.I64:
8941 
          self.warehouseId = iprot.readI64();
8942 
        else:
8943 
          iprot.skip(ftype)
8944 
      elif fid == 3:
8945 
        if ftype == TType.I64:
8946 
          self.quantity = iprot.readI64();
8947 
        else:
8948 
          iprot.skip(ftype)
8949 
      else:
8950 
        iprot.skip(ftype)
8951 
      iprot.readFieldEnd()
8952 
    iprot.readStructEnd()
8953 
 
8954 
  def write(self, oprot):
8955 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8956 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8957 
      return
8958 
    oprot.writeStructBegin('addBadInventory_args')
8959 
    if self.itemId is not None:
8960 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
8961 
      oprot.writeI64(self.itemId)
8962 
      oprot.writeFieldEnd()
8963 
    if self.warehouseId is not None:
8964 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8965 
      oprot.writeI64(self.warehouseId)
8966 
      oprot.writeFieldEnd()
8967 
    if self.quantity is not None:
8968 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
8969 
      oprot.writeI64(self.quantity)
8970 
      oprot.writeFieldEnd()
8971 
    oprot.writeFieldStop()
8972 
    oprot.writeStructEnd()
8973 
 
8974 
  def validate(self):
8975 
    return
8976 
 
8977 
 
8978 
  def __repr__(self):
8979 
    L = ['%s=%r' % (key, value)
8980 
      for key, value in self.__dict__.iteritems()]
8981 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8982 
 
8983 
  def __eq__(self, other):
8984 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8985 
 
8986 
  def __ne__(self, other):
8987 
    return not (self == other)
8988 
 
8989 
class addBadInventory_result:
8990 
  """
8991 
  Attributes:
8992 
   - cex
8993 
  """
8994 
 
8995 
  thrift_spec = (
8996 
    None, # 0
8997 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
8998 
  )
8999 
 
9000 
  def __init__(self, cex=None,):
9001 
    self.cex = cex
9002 
 
9003 
  def read(self, iprot):
9004 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9005 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9006 
      return
9007 
    iprot.readStructBegin()
9008 
    while True:
9009 
      (fname, ftype, fid) = iprot.readFieldBegin()
9010 
      if ftype == TType.STOP:
9011 
        break
9012 
      if fid == 1:
9013 
        if ftype == TType.STRUCT:
9014 
          self.cex = InventoryServiceException()
9015 
          self.cex.read(iprot)
9016 
        else:
9017 
          iprot.skip(ftype)
9018 
      else:
9019 
        iprot.skip(ftype)
9020 
      iprot.readFieldEnd()
9021 
    iprot.readStructEnd()
9022 
 
9023 
  def write(self, oprot):
9024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9026 
      return
9027 
    oprot.writeStructBegin('addBadInventory_result')
9028 
    if self.cex is not None:
9029 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9030 
      self.cex.write(oprot)
9031 
      oprot.writeFieldEnd()
9032 
    oprot.writeFieldStop()
9033 
    oprot.writeStructEnd()
9034 
 
9035 
  def validate(self):
9036 
    return
9037 
 
9038 
 
9039 
  def __repr__(self):
9040 
    L = ['%s=%r' % (key, value)
9041 
      for key, value in self.__dict__.iteritems()]
9042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9043 
 
9044 
  def __eq__(self, other):
9045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9046 
 
9047 
  def __ne__(self, other):
9048 
    return not (self == other)
9049 
 
9050 
class getShippingLocations_args:
9051 
 
9052 
  thrift_spec = (
9053 
  )
9054 
 
9055 
  def read(self, iprot):
9056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9058 
      return
9059 
    iprot.readStructBegin()
9060 
    while True:
9061 
      (fname, ftype, fid) = iprot.readFieldBegin()
9062 
      if ftype == TType.STOP:
9063 
        break
9064 
      else:
9065 
        iprot.skip(ftype)
9066 
      iprot.readFieldEnd()
9067 
    iprot.readStructEnd()
9068 
 
9069 
  def write(self, oprot):
9070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9072 
      return
9073 
    oprot.writeStructBegin('getShippingLocations_args')
9074 
    oprot.writeFieldStop()
9075 
    oprot.writeStructEnd()
9076 
 
9077 
  def validate(self):
9078 
    return
9079 
 
9080 
 
9081 
  def __repr__(self):
9082 
    L = ['%s=%r' % (key, value)
9083 
      for key, value in self.__dict__.iteritems()]
9084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9085 
 
9086 
  def __eq__(self, other):
9087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9088 
 
9089 
  def __ne__(self, other):
9090 
    return not (self == other)
9091 
 
9092 
class getShippingLocations_result:
9093 
  """
9094 
  Attributes:
9095 
   - success
9096 
  """
9097 
 
9098 
  thrift_spec = (
9099 
    (0, TType.LIST, 'success', (TType.STRUCT,(Warehouse, Warehouse.thrift_spec)), None, ), # 0
9100 
  )
9101 
 
9102 
  def __init__(self, success=None,):
9103 
    self.success = success
9104 
 
9105 
  def read(self, iprot):
9106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9108 
      return
9109 
    iprot.readStructBegin()
9110 
    while True:
9111 
      (fname, ftype, fid) = iprot.readFieldBegin()
9112 
      if ftype == TType.STOP:
9113 
        break
9114 
      if fid == 0:
9115 
        if ftype == TType.LIST:
9116 
          self.success = []
8182 amar.kumar 9117 
          (_etype129, _size126) = iprot.readListBegin()
9118 
          for _i130 in xrange(_size126):
9119 
            _elem131 = Warehouse()
9120 
            _elem131.read(iprot)
9121 
            self.success.append(_elem131)
5944 mandeep.dh 9122 
          iprot.readListEnd()
9123 
        else:
9124 
          iprot.skip(ftype)
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('getShippingLocations_result')
9135 
    if self.success is not None:
9136 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9137 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 9138 
      for iter132 in self.success:
9139 
        iter132.write(oprot)
5944 mandeep.dh 9140 
      oprot.writeListEnd()
9141 
      oprot.writeFieldEnd()
9142 
    oprot.writeFieldStop()
9143 
    oprot.writeStructEnd()
9144 
 
9145 
  def validate(self):
9146 
    return
9147 
 
9148 
 
9149 
  def __repr__(self):
9150 
    L = ['%s=%r' % (key, value)
9151 
      for key, value in self.__dict__.iteritems()]
9152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9153 
 
9154 
  def __eq__(self, other):
9155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9156 
 
9157 
  def __ne__(self, other):
9158 
    return not (self == other)
9159 
 
9160 
class getAllVendorItemMappings_args:
9161 
 
9162 
  thrift_spec = (
9163 
  )
9164 
 
9165 
  def read(self, iprot):
9166 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9167 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9168 
      return
9169 
    iprot.readStructBegin()
9170 
    while True:
9171 
      (fname, ftype, fid) = iprot.readFieldBegin()
9172 
      if ftype == TType.STOP:
9173 
        break
9174 
      else:
9175 
        iprot.skip(ftype)
9176 
      iprot.readFieldEnd()
9177 
    iprot.readStructEnd()
9178 
 
9179 
  def write(self, oprot):
9180 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9181 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9182 
      return
9183 
    oprot.writeStructBegin('getAllVendorItemMappings_args')
9184 
    oprot.writeFieldStop()
9185 
    oprot.writeStructEnd()
9186 
 
9187 
  def validate(self):
9188 
    return
9189 
 
9190 
 
9191 
  def __repr__(self):
9192 
    L = ['%s=%r' % (key, value)
9193 
      for key, value in self.__dict__.iteritems()]
9194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9195 
 
9196 
  def __eq__(self, other):
9197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9198 
 
9199 
  def __ne__(self, other):
9200 
    return not (self == other)
9201 
 
9202 
class getAllVendorItemMappings_result:
9203 
  """
9204 
  Attributes:
9205 
   - success
9206 
  """
9207 
 
9208 
  thrift_spec = (
9209 
    (0, TType.LIST, 'success', (TType.STRUCT,(VendorItemMapping, VendorItemMapping.thrift_spec)), None, ), # 0
9210 
  )
9211 
 
9212 
  def __init__(self, success=None,):
9213 
    self.success = success
9214 
 
9215 
  def read(self, iprot):
9216 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9217 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9218 
      return
9219 
    iprot.readStructBegin()
9220 
    while True:
9221 
      (fname, ftype, fid) = iprot.readFieldBegin()
9222 
      if ftype == TType.STOP:
9223 
        break
9224 
      if fid == 0:
9225 
        if ftype == TType.LIST:
9226 
          self.success = []
8182 amar.kumar 9227 
          (_etype136, _size133) = iprot.readListBegin()
9228 
          for _i137 in xrange(_size133):
9229 
            _elem138 = VendorItemMapping()
9230 
            _elem138.read(iprot)
9231 
            self.success.append(_elem138)
5944 mandeep.dh 9232 
          iprot.readListEnd()
9233 
        else:
9234 
          iprot.skip(ftype)
9235 
      else:
9236 
        iprot.skip(ftype)
9237 
      iprot.readFieldEnd()
9238 
    iprot.readStructEnd()
9239 
 
9240 
  def write(self, oprot):
9241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9243 
      return
9244 
    oprot.writeStructBegin('getAllVendorItemMappings_result')
9245 
    if self.success is not None:
9246 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9247 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 9248 
      for iter139 in self.success:
9249 
        iter139.write(oprot)
5944 mandeep.dh 9250 
      oprot.writeListEnd()
9251 
      oprot.writeFieldEnd()
9252 
    oprot.writeFieldStop()
9253 
    oprot.writeStructEnd()
9254 
 
9255 
  def validate(self):
9256 
    return
9257 
 
9258 
 
9259 
  def __repr__(self):
9260 
    L = ['%s=%r' % (key, value)
9261 
      for key, value in self.__dict__.iteritems()]
9262 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9263 
 
9264 
  def __eq__(self, other):
9265 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9266 
 
9267 
  def __ne__(self, other):
9268 
    return not (self == other)
9269 
 
9270 
class getInventorySnapshot_args:
9271 
  """
9272 
  Attributes:
9273 
   - warehouseId
9274 
  """
9275 
 
9276 
  thrift_spec = (
9277 
    None, # 0
9278 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9279 
  )
9280 
 
9281 
  def __init__(self, warehouseId=None,):
9282 
    self.warehouseId = warehouseId
9283 
 
9284 
  def read(self, iprot):
9285 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9286 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9287 
      return
9288 
    iprot.readStructBegin()
9289 
    while True:
9290 
      (fname, ftype, fid) = iprot.readFieldBegin()
9291 
      if ftype == TType.STOP:
9292 
        break
9293 
      if fid == 1:
9294 
        if ftype == TType.I64:
9295 
          self.warehouseId = iprot.readI64();
9296 
        else:
9297 
          iprot.skip(ftype)
9298 
      else:
9299 
        iprot.skip(ftype)
9300 
      iprot.readFieldEnd()
9301 
    iprot.readStructEnd()
9302 
 
9303 
  def write(self, oprot):
9304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9306 
      return
9307 
    oprot.writeStructBegin('getInventorySnapshot_args')
9308 
    if self.warehouseId is not None:
9309 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9310 
      oprot.writeI64(self.warehouseId)
9311 
      oprot.writeFieldEnd()
9312 
    oprot.writeFieldStop()
9313 
    oprot.writeStructEnd()
9314 
 
9315 
  def validate(self):
9316 
    return
9317 
 
9318 
 
9319 
  def __repr__(self):
9320 
    L = ['%s=%r' % (key, value)
9321 
      for key, value in self.__dict__.iteritems()]
9322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9323 
 
9324 
  def __eq__(self, other):
9325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9326 
 
9327 
  def __ne__(self, other):
9328 
    return not (self == other)
9329 
 
9330 
class getInventorySnapshot_result:
9331 
  """
9332 
  Attributes:
9333 
   - success
9334 
  """
9335 
 
9336 
  thrift_spec = (
9337 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRUCT,(ItemInventory, ItemInventory.thrift_spec)), None, ), # 0
9338 
  )
9339 
 
9340 
  def __init__(self, success=None,):
9341 
    self.success = success
9342 
 
9343 
  def read(self, iprot):
9344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9346 
      return
9347 
    iprot.readStructBegin()
9348 
    while True:
9349 
      (fname, ftype, fid) = iprot.readFieldBegin()
9350 
      if ftype == TType.STOP:
9351 
        break
9352 
      if fid == 0:
9353 
        if ftype == TType.MAP:
9354 
          self.success = {}
8182 amar.kumar 9355 
          (_ktype141, _vtype142, _size140 ) = iprot.readMapBegin()
9356 
          for _i144 in xrange(_size140):
9357 
            _key145 = iprot.readI64();
9358 
            _val146 = ItemInventory()
9359 
            _val146.read(iprot)
9360 
            self.success[_key145] = _val146
5944 mandeep.dh 9361 
          iprot.readMapEnd()
9362 
        else:
9363 
          iprot.skip(ftype)
9364 
      else:
9365 
        iprot.skip(ftype)
9366 
      iprot.readFieldEnd()
9367 
    iprot.readStructEnd()
9368 
 
9369 
  def write(self, oprot):
9370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9372 
      return
9373 
    oprot.writeStructBegin('getInventorySnapshot_result')
9374 
    if self.success is not None:
9375 
      oprot.writeFieldBegin('success', TType.MAP, 0)
9376 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.success))
8182 amar.kumar 9377 
      for kiter147,viter148 in self.success.items():
9378 
        oprot.writeI64(kiter147)
9379 
        viter148.write(oprot)
5944 mandeep.dh 9380 
      oprot.writeMapEnd()
9381 
      oprot.writeFieldEnd()
9382 
    oprot.writeFieldStop()
9383 
    oprot.writeStructEnd()
9384 
 
9385 
  def validate(self):
9386 
    return
9387 
 
9388 
 
9389 
  def __repr__(self):
9390 
    L = ['%s=%r' % (key, value)
9391 
      for key, value in self.__dict__.iteritems()]
9392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9393 
 
9394 
  def __eq__(self, other):
9395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9396 
 
9397 
  def __ne__(self, other):
9398 
    return not (self == other)
9399 
 
9400 
class clearItemAvailabilityCache_args:
9401 
 
9402 
  thrift_spec = (
9403 
  )
9404 
 
9405 
  def read(self, iprot):
9406 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9407 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9408 
      return
9409 
    iprot.readStructBegin()
9410 
    while True:
9411 
      (fname, ftype, fid) = iprot.readFieldBegin()
9412 
      if ftype == TType.STOP:
9413 
        break
9414 
      else:
9415 
        iprot.skip(ftype)
9416 
      iprot.readFieldEnd()
9417 
    iprot.readStructEnd()
9418 
 
9419 
  def write(self, oprot):
9420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9422 
      return
9423 
    oprot.writeStructBegin('clearItemAvailabilityCache_args')
9424 
    oprot.writeFieldStop()
9425 
    oprot.writeStructEnd()
9426 
 
9427 
  def validate(self):
9428 
    return
9429 
 
9430 
 
9431 
  def __repr__(self):
9432 
    L = ['%s=%r' % (key, value)
9433 
      for key, value in self.__dict__.iteritems()]
9434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9435 
 
9436 
  def __eq__(self, other):
9437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9438 
 
9439 
  def __ne__(self, other):
9440 
    return not (self == other)
9441 
 
9442 
class clearItemAvailabilityCache_result:
9443 
 
9444 
  thrift_spec = (
9445 
  )
9446 
 
9447 
  def read(self, iprot):
9448 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9449 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9450 
      return
9451 
    iprot.readStructBegin()
9452 
    while True:
9453 
      (fname, ftype, fid) = iprot.readFieldBegin()
9454 
      if ftype == TType.STOP:
9455 
        break
9456 
      else:
9457 
        iprot.skip(ftype)
9458 
      iprot.readFieldEnd()
9459 
    iprot.readStructEnd()
9460 
 
9461 
  def write(self, oprot):
9462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9464 
      return
9465 
    oprot.writeStructBegin('clearItemAvailabilityCache_result')
9466 
    oprot.writeFieldStop()
9467 
    oprot.writeStructEnd()
9468 
 
9469 
  def validate(self):
9470 
    return
9471 
 
9472 
 
9473 
  def __repr__(self):
9474 
    L = ['%s=%r' % (key, value)
9475 
      for key, value in self.__dict__.iteritems()]
9476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9477 
 
9478 
  def __eq__(self, other):
9479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9480 
 
9481 
  def __ne__(self, other):
9482 
    return not (self == other)
9483 
 
9484 
class updateVendorString_args:
9485 
  """
9486 
  Attributes:
9487 
   - warehouseId
9488 
   - vendorString
9489 
  """
9490 
 
9491 
  thrift_spec = (
9492 
    None, # 0
9493 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9494 
    (2, TType.STRING, 'vendorString', None, None, ), # 2
9495 
  )
9496 
 
9497 
  def __init__(self, warehouseId=None, vendorString=None,):
9498 
    self.warehouseId = warehouseId
9499 
    self.vendorString = vendorString
9500 
 
9501 
  def read(self, iprot):
9502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9504 
      return
9505 
    iprot.readStructBegin()
9506 
    while True:
9507 
      (fname, ftype, fid) = iprot.readFieldBegin()
9508 
      if ftype == TType.STOP:
9509 
        break
9510 
      if fid == 1:
9511 
        if ftype == TType.I64:
9512 
          self.warehouseId = iprot.readI64();
9513 
        else:
9514 
          iprot.skip(ftype)
9515 
      elif fid == 2:
9516 
        if ftype == TType.STRING:
9517 
          self.vendorString = iprot.readString();
9518 
        else:
9519 
          iprot.skip(ftype)
9520 
      else:
9521 
        iprot.skip(ftype)
9522 
      iprot.readFieldEnd()
9523 
    iprot.readStructEnd()
9524 
 
9525 
  def write(self, oprot):
9526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9528 
      return
9529 
    oprot.writeStructBegin('updateVendorString_args')
9530 
    if self.warehouseId is not None:
9531 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9532 
      oprot.writeI64(self.warehouseId)
9533 
      oprot.writeFieldEnd()
9534 
    if self.vendorString is not None:
9535 
      oprot.writeFieldBegin('vendorString', TType.STRING, 2)
9536 
      oprot.writeString(self.vendorString)
9537 
      oprot.writeFieldEnd()
9538 
    oprot.writeFieldStop()
9539 
    oprot.writeStructEnd()
9540 
 
9541 
  def validate(self):
9542 
    return
9543 
 
9544 
 
9545 
  def __repr__(self):
9546 
    L = ['%s=%r' % (key, value)
9547 
      for key, value in self.__dict__.iteritems()]
9548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9549 
 
9550 
  def __eq__(self, other):
9551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9552 
 
9553 
  def __ne__(self, other):
9554 
    return not (self == other)
9555 
 
9556 
class updateVendorString_result:
9557 
 
9558 
  thrift_spec = (
9559 
  )
9560 
 
9561 
  def read(self, iprot):
9562 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9563 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9564 
      return
9565 
    iprot.readStructBegin()
9566 
    while True:
9567 
      (fname, ftype, fid) = iprot.readFieldBegin()
9568 
      if ftype == TType.STOP:
9569 
        break
9570 
      else:
9571 
        iprot.skip(ftype)
9572 
      iprot.readFieldEnd()
9573 
    iprot.readStructEnd()
9574 
 
9575 
  def write(self, oprot):
9576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9578 
      return
9579 
    oprot.writeStructBegin('updateVendorString_result')
9580 
    oprot.writeFieldStop()
9581 
    oprot.writeStructEnd()
9582 
 
9583 
  def validate(self):
9584 
    return
9585 
 
9586 
 
9587 
  def __repr__(self):
9588 
    L = ['%s=%r' % (key, value)
9589 
      for key, value in self.__dict__.iteritems()]
9590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9591 
 
9592 
  def __eq__(self, other):
9593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9594 
 
9595 
  def __ne__(self, other):
9596 
    return not (self == other)
6096 amit.gupta 9597 
 
9598 
class clearItemAvailabilityCacheForItem_args:
9599 
  """
9600 
  Attributes:
9601 
   - item_id
9602 
  """
9603 
 
9604 
  thrift_spec = (
9605 
    None, # 0
9606 
    (1, TType.I64, 'item_id', None, None, ), # 1
9607 
  )
9608 
 
9609 
  def __init__(self, item_id=None,):
9610 
    self.item_id = item_id
9611 
 
9612 
  def read(self, iprot):
9613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9615 
      return
9616 
    iprot.readStructBegin()
9617 
    while True:
9618 
      (fname, ftype, fid) = iprot.readFieldBegin()
9619 
      if ftype == TType.STOP:
9620 
        break
9621 
      if fid == 1:
9622 
        if ftype == TType.I64:
9623 
          self.item_id = iprot.readI64();
9624 
        else:
9625 
          iprot.skip(ftype)
9626 
      else:
9627 
        iprot.skip(ftype)
9628 
      iprot.readFieldEnd()
9629 
    iprot.readStructEnd()
9630 
 
9631 
  def write(self, oprot):
9632 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9633 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9634 
      return
9635 
    oprot.writeStructBegin('clearItemAvailabilityCacheForItem_args')
9636 
    if self.item_id is not None:
9637 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
9638 
      oprot.writeI64(self.item_id)
9639 
      oprot.writeFieldEnd()
9640 
    oprot.writeFieldStop()
9641 
    oprot.writeStructEnd()
9642 
 
9643 
  def validate(self):
9644 
    return
9645 
 
9646 
 
9647 
  def __repr__(self):
9648 
    L = ['%s=%r' % (key, value)
9649 
      for key, value in self.__dict__.iteritems()]
9650 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9651 
 
9652 
  def __eq__(self, other):
9653 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9654 
 
9655 
  def __ne__(self, other):
9656 
    return not (self == other)
9657 
 
9658 
class clearItemAvailabilityCacheForItem_result:
9659 
 
9660 
  thrift_spec = (
9661 
  )
9662 
 
9663 
  def read(self, iprot):
9664 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9665 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9666 
      return
9667 
    iprot.readStructBegin()
9668 
    while True:
9669 
      (fname, ftype, fid) = iprot.readFieldBegin()
9670 
      if ftype == TType.STOP:
9671 
        break
9672 
      else:
9673 
        iprot.skip(ftype)
9674 
      iprot.readFieldEnd()
9675 
    iprot.readStructEnd()
9676 
 
9677 
  def write(self, oprot):
9678 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9679 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9680 
      return
9681 
    oprot.writeStructBegin('clearItemAvailabilityCacheForItem_result')
9682 
    oprot.writeFieldStop()
9683 
    oprot.writeStructEnd()
9684 
 
9685 
  def validate(self):
9686 
    return
9687 
 
9688 
 
9689 
  def __repr__(self):
9690 
    L = ['%s=%r' % (key, value)
9691 
      for key, value in self.__dict__.iteritems()]
9692 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9693 
 
9694 
  def __eq__(self, other):
9695 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9696 
 
9697 
  def __ne__(self, other):
9698 
    return not (self == other)
6467 amar.kumar 9699 
 
9700 
class getOurWarehouseIdForVendor_args:
9701 
  """
9702 
  Attributes:
9703 
   - vendorId
7718 amar.kumar 9704 
   - billingWarehouseId
6467 amar.kumar 9705 
  """
9706 
 
9707 
  thrift_spec = (
9708 
    None, # 0
9709 
    (1, TType.I64, 'vendorId', None, None, ), # 1
7718 amar.kumar 9710 
    (2, TType.I64, 'billingWarehouseId', None, None, ), # 2
6467 amar.kumar 9711 
  )
9712 
 
7718 amar.kumar 9713 
  def __init__(self, vendorId=None, billingWarehouseId=None,):
6467 amar.kumar 9714 
    self.vendorId = vendorId
7718 amar.kumar 9715 
    self.billingWarehouseId = billingWarehouseId
6467 amar.kumar 9716 
 
9717 
  def read(self, iprot):
9718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9720 
      return
9721 
    iprot.readStructBegin()
9722 
    while True:
9723 
      (fname, ftype, fid) = iprot.readFieldBegin()
9724 
      if ftype == TType.STOP:
9725 
        break
9726 
      if fid == 1:
9727 
        if ftype == TType.I64:
9728 
          self.vendorId = iprot.readI64();
9729 
        else:
9730 
          iprot.skip(ftype)
7718 amar.kumar 9731 
      elif fid == 2:
9732 
        if ftype == TType.I64:
9733 
          self.billingWarehouseId = iprot.readI64();
9734 
        else:
9735 
          iprot.skip(ftype)
6467 amar.kumar 9736 
      else:
9737 
        iprot.skip(ftype)
9738 
      iprot.readFieldEnd()
9739 
    iprot.readStructEnd()
9740 
 
9741 
  def write(self, oprot):
9742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9744 
      return
9745 
    oprot.writeStructBegin('getOurWarehouseIdForVendor_args')
9746 
    if self.vendorId is not None:
9747 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
9748 
      oprot.writeI64(self.vendorId)
9749 
      oprot.writeFieldEnd()
7718 amar.kumar 9750 
    if self.billingWarehouseId is not None:
9751 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 2)
9752 
      oprot.writeI64(self.billingWarehouseId)
9753 
      oprot.writeFieldEnd()
6467 amar.kumar 9754 
    oprot.writeFieldStop()
9755 
    oprot.writeStructEnd()
9756 
 
9757 
  def validate(self):
9758 
    return
9759 
 
9760 
 
9761 
  def __repr__(self):
9762 
    L = ['%s=%r' % (key, value)
9763 
      for key, value in self.__dict__.iteritems()]
9764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9765 
 
9766 
  def __eq__(self, other):
9767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9768 
 
9769 
  def __ne__(self, other):
9770 
    return not (self == other)
9771 
 
9772 
class getOurWarehouseIdForVendor_result:
9773 
  """
9774 
  Attributes:
9775 
   - success
9776 
  """
9777 
 
9778 
  thrift_spec = (
9779 
    (0, TType.I64, 'success', None, None, ), # 0
9780 
  )
9781 
 
9782 
  def __init__(self, success=None,):
9783 
    self.success = success
9784 
 
9785 
  def read(self, iprot):
9786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9788 
      return
9789 
    iprot.readStructBegin()
9790 
    while True:
9791 
      (fname, ftype, fid) = iprot.readFieldBegin()
9792 
      if ftype == TType.STOP:
9793 
        break
9794 
      if fid == 0:
9795 
        if ftype == TType.I64:
9796 
          self.success = iprot.readI64();
9797 
        else:
9798 
          iprot.skip(ftype)
9799 
      else:
9800 
        iprot.skip(ftype)
9801 
      iprot.readFieldEnd()
9802 
    iprot.readStructEnd()
9803 
 
9804 
  def write(self, oprot):
9805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9807 
      return
9808 
    oprot.writeStructBegin('getOurWarehouseIdForVendor_result')
9809 
    if self.success is not None:
9810 
      oprot.writeFieldBegin('success', TType.I64, 0)
9811 
      oprot.writeI64(self.success)
9812 
      oprot.writeFieldEnd()
9813 
    oprot.writeFieldStop()
9814 
    oprot.writeStructEnd()
9815 
 
9816 
  def validate(self):
9817 
    return
9818 
 
9819 
 
9820 
  def __repr__(self):
9821 
    L = ['%s=%r' % (key, value)
9822 
      for key, value in self.__dict__.iteritems()]
9823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9824 
 
9825 
  def __eq__(self, other):
9826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9827 
 
9828 
  def __ne__(self, other):
9829 
    return not (self == other)
6484 amar.kumar 9830 
 
9831 
class getItemAvailabilitiesAtOurWarehouses_args:
9832 
  """
9833 
  Attributes:
9834 
   - item_ids
9835 
  """
9836 
 
9837 
  thrift_spec = (
9838 
    None, # 0
9839 
    (1, TType.LIST, 'item_ids', (TType.I64,None), None, ), # 1
9840 
  )
9841 
 
9842 
  def __init__(self, item_ids=None,):
9843 
    self.item_ids = item_ids
9844 
 
9845 
  def read(self, iprot):
9846 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9847 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9848 
      return
9849 
    iprot.readStructBegin()
9850 
    while True:
9851 
      (fname, ftype, fid) = iprot.readFieldBegin()
9852 
      if ftype == TType.STOP:
9853 
        break
9854 
      if fid == 1:
9855 
        if ftype == TType.LIST:
9856 
          self.item_ids = []
8182 amar.kumar 9857 
          (_etype152, _size149) = iprot.readListBegin()
9858 
          for _i153 in xrange(_size149):
9859 
            _elem154 = iprot.readI64();
9860 
            self.item_ids.append(_elem154)
6484 amar.kumar 9861 
          iprot.readListEnd()
9862 
        else:
9863 
          iprot.skip(ftype)
9864 
      else:
9865 
        iprot.skip(ftype)
9866 
      iprot.readFieldEnd()
9867 
    iprot.readStructEnd()
9868 
 
9869 
  def write(self, oprot):
9870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9872 
      return
9873 
    oprot.writeStructBegin('getItemAvailabilitiesAtOurWarehouses_args')
9874 
    if self.item_ids is not None:
9875 
      oprot.writeFieldBegin('item_ids', TType.LIST, 1)
9876 
      oprot.writeListBegin(TType.I64, len(self.item_ids))
8182 amar.kumar 9877 
      for iter155 in self.item_ids:
9878 
        oprot.writeI64(iter155)
6484 amar.kumar 9879 
      oprot.writeListEnd()
9880 
      oprot.writeFieldEnd()
9881 
    oprot.writeFieldStop()
9882 
    oprot.writeStructEnd()
9883 
 
9884 
  def validate(self):
9885 
    return
9886 
 
9887 
 
9888 
  def __repr__(self):
9889 
    L = ['%s=%r' % (key, value)
9890 
      for key, value in self.__dict__.iteritems()]
9891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9892 
 
9893 
  def __eq__(self, other):
9894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9895 
 
9896 
  def __ne__(self, other):
9897 
    return not (self == other)
9898 
 
9899 
class getItemAvailabilitiesAtOurWarehouses_result:
9900 
  """
9901 
  Attributes:
9902 
   - success
9903 
  """
9904 
 
9905 
  thrift_spec = (
9906 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
9907 
  )
9908 
 
9909 
  def __init__(self, success=None,):
9910 
    self.success = success
9911 
 
9912 
  def read(self, iprot):
9913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9915 
      return
9916 
    iprot.readStructBegin()
9917 
    while True:
9918 
      (fname, ftype, fid) = iprot.readFieldBegin()
9919 
      if ftype == TType.STOP:
9920 
        break
9921 
      if fid == 0:
9922 
        if ftype == TType.MAP:
9923 
          self.success = {}
8182 amar.kumar 9924 
          (_ktype157, _vtype158, _size156 ) = iprot.readMapBegin()
9925 
          for _i160 in xrange(_size156):
9926 
            _key161 = iprot.readI64();
9927 
            _val162 = iprot.readI64();
9928 
            self.success[_key161] = _val162
6484 amar.kumar 9929 
          iprot.readMapEnd()
9930 
        else:
9931 
          iprot.skip(ftype)
9932 
      else:
9933 
        iprot.skip(ftype)
9934 
      iprot.readFieldEnd()
9935 
    iprot.readStructEnd()
9936 
 
9937 
  def write(self, oprot):
9938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9940 
      return
9941 
    oprot.writeStructBegin('getItemAvailabilitiesAtOurWarehouses_result')
9942 
    if self.success is not None:
9943 
      oprot.writeFieldBegin('success', TType.MAP, 0)
9944 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
8182 amar.kumar 9945 
      for kiter163,viter164 in self.success.items():
9946 
        oprot.writeI64(kiter163)
9947 
        oprot.writeI64(viter164)
6484 amar.kumar 9948 
      oprot.writeMapEnd()
9949 
      oprot.writeFieldEnd()
9950 
    oprot.writeFieldStop()
9951 
    oprot.writeStructEnd()
9952 
 
9953 
  def validate(self):
9954 
    return
9955 
 
9956 
 
9957 
  def __repr__(self):
9958 
    L = ['%s=%r' % (key, value)
9959 
      for key, value in self.__dict__.iteritems()]
9960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9961 
 
9962 
  def __eq__(self, other):
9963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9964 
 
9965 
  def __ne__(self, other):
9966 
    return not (self == other)
6531 vikram.rag 9967 
 
9968 
class getMonitoredWarehouseForVendors_args:
9969 
  """
9970 
  Attributes:
9971 
   - vendorIds
9972 
  """
9973 
 
9974 
  thrift_spec = (
9975 
    None, # 0
9976 
    (1, TType.LIST, 'vendorIds', (TType.I64,None), None, ), # 1
9977 
  )
9978 
 
9979 
  def __init__(self, vendorIds=None,):
9980 
    self.vendorIds = vendorIds
9981 
 
9982 
  def read(self, iprot):
9983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9985 
      return
9986 
    iprot.readStructBegin()
9987 
    while True:
9988 
      (fname, ftype, fid) = iprot.readFieldBegin()
9989 
      if ftype == TType.STOP:
9990 
        break
9991 
      if fid == 1:
9992 
        if ftype == TType.LIST:
9993 
          self.vendorIds = []
8182 amar.kumar 9994 
          (_etype168, _size165) = iprot.readListBegin()
9995 
          for _i169 in xrange(_size165):
9996 
            _elem170 = iprot.readI64();
9997 
            self.vendorIds.append(_elem170)
6531 vikram.rag 9998 
          iprot.readListEnd()
9999 
        else:
10000 
          iprot.skip(ftype)
10001 
      else:
10002 
        iprot.skip(ftype)
10003 
      iprot.readFieldEnd()
10004 
    iprot.readStructEnd()
10005 
 
10006 
  def write(self, oprot):
10007 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10008 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10009 
      return
10010 
    oprot.writeStructBegin('getMonitoredWarehouseForVendors_args')
10011 
    if self.vendorIds is not None:
10012 
      oprot.writeFieldBegin('vendorIds', TType.LIST, 1)
10013 
      oprot.writeListBegin(TType.I64, len(self.vendorIds))
8182 amar.kumar 10014 
      for iter171 in self.vendorIds:
10015 
        oprot.writeI64(iter171)
6531 vikram.rag 10016 
      oprot.writeListEnd()
10017 
      oprot.writeFieldEnd()
10018 
    oprot.writeFieldStop()
10019 
    oprot.writeStructEnd()
10020 
 
10021 
  def validate(self):
10022 
    return
10023 
 
10024 
 
10025 
  def __repr__(self):
10026 
    L = ['%s=%r' % (key, value)
10027 
      for key, value in self.__dict__.iteritems()]
10028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10029 
 
10030 
  def __eq__(self, other):
10031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10032 
 
10033 
  def __ne__(self, other):
10034 
    return not (self == other)
10035 
 
10036 
class getMonitoredWarehouseForVendors_result:
10037 
  """
10038 
  Attributes:
10039 
   - success
10040 
  """
10041 
 
10042 
  thrift_spec = (
10043 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10044 
  )
10045 
 
10046 
  def __init__(self, success=None,):
10047 
    self.success = success
10048 
 
10049 
  def read(self, iprot):
10050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10052 
      return
10053 
    iprot.readStructBegin()
10054 
    while True:
10055 
      (fname, ftype, fid) = iprot.readFieldBegin()
10056 
      if ftype == TType.STOP:
10057 
        break
10058 
      if fid == 0:
10059 
        if ftype == TType.LIST:
10060 
          self.success = []
8182 amar.kumar 10061 
          (_etype175, _size172) = iprot.readListBegin()
10062 
          for _i176 in xrange(_size172):
10063 
            _elem177 = iprot.readI64();
10064 
            self.success.append(_elem177)
6531 vikram.rag 10065 
          iprot.readListEnd()
10066 
        else:
10067 
          iprot.skip(ftype)
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('getMonitoredWarehouseForVendors_result')
10078 
    if self.success is not None:
10079 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10080 
      oprot.writeListBegin(TType.I64, len(self.success))
8182 amar.kumar 10081 
      for iter178 in self.success:
10082 
        oprot.writeI64(iter178)
6531 vikram.rag 10083 
      oprot.writeListEnd()
10084 
      oprot.writeFieldEnd()
10085 
    oprot.writeFieldStop()
10086 
    oprot.writeStructEnd()
10087 
 
10088 
  def validate(self):
10089 
    return
10090 
 
10091 
 
10092 
  def __repr__(self):
10093 
    L = ['%s=%r' % (key, value)
10094 
      for key, value in self.__dict__.iteritems()]
10095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10096 
 
10097 
  def __eq__(self, other):
10098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10099 
 
10100 
  def __ne__(self, other):
10101 
    return not (self == other)
10102 
 
10103 
class getIgnoredWarehouseidsAndItemids_args:
10104 
 
10105 
  thrift_spec = (
10106 
  )
10107 
 
10108 
  def read(self, iprot):
10109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10111 
      return
10112 
    iprot.readStructBegin()
10113 
    while True:
10114 
      (fname, ftype, fid) = iprot.readFieldBegin()
10115 
      if ftype == TType.STOP:
10116 
        break
10117 
      else:
10118 
        iprot.skip(ftype)
10119 
      iprot.readFieldEnd()
10120 
    iprot.readStructEnd()
10121 
 
10122 
  def write(self, oprot):
10123 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10124 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10125 
      return
10126 
    oprot.writeStructBegin('getIgnoredWarehouseidsAndItemids_args')
10127 
    oprot.writeFieldStop()
10128 
    oprot.writeStructEnd()
10129 
 
10130 
  def validate(self):
10131 
    return
10132 
 
10133 
 
10134 
  def __repr__(self):
10135 
    L = ['%s=%r' % (key, value)
10136 
      for key, value in self.__dict__.iteritems()]
10137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10138 
 
10139 
  def __eq__(self, other):
10140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10141 
 
10142 
  def __ne__(self, other):
10143 
    return not (self == other)
10144 
 
10145 
class getIgnoredWarehouseidsAndItemids_result:
10146 
  """
10147 
  Attributes:
10148 
   - success
10149 
  """
10150 
 
10151 
  thrift_spec = (
10152 
    (0, TType.LIST, 'success', (TType.STRUCT,(IgnoredInventoryUpdateItems, IgnoredInventoryUpdateItems.thrift_spec)), None, ), # 0
10153 
  )
10154 
 
10155 
  def __init__(self, success=None,):
10156 
    self.success = success
10157 
 
10158 
  def read(self, iprot):
10159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10161 
      return
10162 
    iprot.readStructBegin()
10163 
    while True:
10164 
      (fname, ftype, fid) = iprot.readFieldBegin()
10165 
      if ftype == TType.STOP:
10166 
        break
10167 
      if fid == 0:
10168 
        if ftype == TType.LIST:
10169 
          self.success = []
8182 amar.kumar 10170 
          (_etype182, _size179) = iprot.readListBegin()
10171 
          for _i183 in xrange(_size179):
10172 
            _elem184 = IgnoredInventoryUpdateItems()
10173 
            _elem184.read(iprot)
10174 
            self.success.append(_elem184)
6531 vikram.rag 10175 
          iprot.readListEnd()
10176 
        else:
10177 
          iprot.skip(ftype)
10178 
      else:
10179 
        iprot.skip(ftype)
10180 
      iprot.readFieldEnd()
10181 
    iprot.readStructEnd()
10182 
 
10183 
  def write(self, oprot):
10184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10186 
      return
10187 
    oprot.writeStructBegin('getIgnoredWarehouseidsAndItemids_result')
10188 
    if self.success is not None:
10189 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10190 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 10191 
      for iter185 in self.success:
10192 
        iter185.write(oprot)
6531 vikram.rag 10193 
      oprot.writeListEnd()
10194 
      oprot.writeFieldEnd()
10195 
    oprot.writeFieldStop()
10196 
    oprot.writeStructEnd()
10197 
 
10198 
  def validate(self):
10199 
    return
10200 
 
10201 
 
10202 
  def __repr__(self):
10203 
    L = ['%s=%r' % (key, value)
10204 
      for key, value in self.__dict__.iteritems()]
10205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10206 
 
10207 
  def __eq__(self, other):
10208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10209 
 
10210 
  def __ne__(self, other):
10211 
    return not (self == other)
10212 
 
10213 
class insertItemtoIgnoreInventoryUpdatelist_args:
10214 
  """
10215 
  Attributes:
10216 
   - item_id
10217 
   - warehouse_id
10218 
  """
10219 
 
10220 
  thrift_spec = (
10221 
    None, # 0
10222 
    (1, TType.I64, 'item_id', None, None, ), # 1
10223 
    (2, TType.I64, 'warehouse_id', None, None, ), # 2
10224 
  )
10225 
 
10226 
  def __init__(self, item_id=None, warehouse_id=None,):
10227 
    self.item_id = item_id
10228 
    self.warehouse_id = warehouse_id
10229 
 
10230 
  def read(self, iprot):
10231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10233 
      return
10234 
    iprot.readStructBegin()
10235 
    while True:
10236 
      (fname, ftype, fid) = iprot.readFieldBegin()
10237 
      if ftype == TType.STOP:
10238 
        break
10239 
      if fid == 1:
10240 
        if ftype == TType.I64:
10241 
          self.item_id = iprot.readI64();
10242 
        else:
10243 
          iprot.skip(ftype)
10244 
      elif fid == 2:
10245 
        if ftype == TType.I64:
10246 
          self.warehouse_id = iprot.readI64();
10247 
        else:
10248 
          iprot.skip(ftype)
10249 
      else:
10250 
        iprot.skip(ftype)
10251 
      iprot.readFieldEnd()
10252 
    iprot.readStructEnd()
10253 
 
10254 
  def write(self, oprot):
10255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10257 
      return
10258 
    oprot.writeStructBegin('insertItemtoIgnoreInventoryUpdatelist_args')
10259 
    if self.item_id is not None:
10260 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
10261 
      oprot.writeI64(self.item_id)
10262 
      oprot.writeFieldEnd()
10263 
    if self.warehouse_id is not None:
10264 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 2)
10265 
      oprot.writeI64(self.warehouse_id)
10266 
      oprot.writeFieldEnd()
10267 
    oprot.writeFieldStop()
10268 
    oprot.writeStructEnd()
10269 
 
10270 
  def validate(self):
10271 
    return
10272 
 
10273 
 
10274 
  def __repr__(self):
10275 
    L = ['%s=%r' % (key, value)
10276 
      for key, value in self.__dict__.iteritems()]
10277 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10278 
 
10279 
  def __eq__(self, other):
10280 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10281 
 
10282 
  def __ne__(self, other):
10283 
    return not (self == other)
10284 
 
10285 
class insertItemtoIgnoreInventoryUpdatelist_result:
10286 
  """
10287 
  Attributes:
10288 
   - success
10289 
  """
10290 
 
10291 
  thrift_spec = (
10292 
    (0, TType.BOOL, 'success', None, None, ), # 0
10293 
  )
10294 
 
10295 
  def __init__(self, success=None,):
10296 
    self.success = success
10297 
 
10298 
  def read(self, iprot):
10299 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10300 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10301 
      return
10302 
    iprot.readStructBegin()
10303 
    while True:
10304 
      (fname, ftype, fid) = iprot.readFieldBegin()
10305 
      if ftype == TType.STOP:
10306 
        break
10307 
      if fid == 0:
10308 
        if ftype == TType.BOOL:
10309 
          self.success = iprot.readBool();
10310 
        else:
10311 
          iprot.skip(ftype)
10312 
      else:
10313 
        iprot.skip(ftype)
10314 
      iprot.readFieldEnd()
10315 
    iprot.readStructEnd()
10316 
 
10317 
  def write(self, oprot):
10318 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10319 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10320 
      return
10321 
    oprot.writeStructBegin('insertItemtoIgnoreInventoryUpdatelist_result')
10322 
    if self.success is not None:
10323 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10324 
      oprot.writeBool(self.success)
10325 
      oprot.writeFieldEnd()
10326 
    oprot.writeFieldStop()
10327 
    oprot.writeStructEnd()
10328 
 
10329 
  def validate(self):
10330 
    return
10331 
 
10332 
 
10333 
  def __repr__(self):
10334 
    L = ['%s=%r' % (key, value)
10335 
      for key, value in self.__dict__.iteritems()]
10336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10337 
 
10338 
  def __eq__(self, other):
10339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10340 
 
10341 
  def __ne__(self, other):
10342 
    return not (self == other)
10343 
 
10344 
class deleteItemFromIgnoredInventoryUpdateList_args:
10345 
  """
10346 
  Attributes:
10347 
   - item_id
10348 
   - warehouse_id
10349 
  """
10350 
 
10351 
  thrift_spec = (
10352 
    None, # 0
10353 
    (1, TType.I64, 'item_id', None, None, ), # 1
10354 
    (2, TType.I64, 'warehouse_id', None, None, ), # 2
10355 
  )
10356 
 
10357 
  def __init__(self, item_id=None, warehouse_id=None,):
10358 
    self.item_id = item_id
10359 
    self.warehouse_id = warehouse_id
10360 
 
10361 
  def read(self, iprot):
10362 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10363 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10364 
      return
10365 
    iprot.readStructBegin()
10366 
    while True:
10367 
      (fname, ftype, fid) = iprot.readFieldBegin()
10368 
      if ftype == TType.STOP:
10369 
        break
10370 
      if fid == 1:
10371 
        if ftype == TType.I64:
10372 
          self.item_id = iprot.readI64();
10373 
        else:
10374 
          iprot.skip(ftype)
10375 
      elif fid == 2:
10376 
        if ftype == TType.I64:
10377 
          self.warehouse_id = iprot.readI64();
10378 
        else:
10379 
          iprot.skip(ftype)
10380 
      else:
10381 
        iprot.skip(ftype)
10382 
      iprot.readFieldEnd()
10383 
    iprot.readStructEnd()
10384 
 
10385 
  def write(self, oprot):
10386 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10387 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10388 
      return
10389 
    oprot.writeStructBegin('deleteItemFromIgnoredInventoryUpdateList_args')
10390 
    if self.item_id is not None:
10391 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
10392 
      oprot.writeI64(self.item_id)
10393 
      oprot.writeFieldEnd()
10394 
    if self.warehouse_id is not None:
10395 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 2)
10396 
      oprot.writeI64(self.warehouse_id)
10397 
      oprot.writeFieldEnd()
10398 
    oprot.writeFieldStop()
10399 
    oprot.writeStructEnd()
10400 
 
10401 
  def validate(self):
10402 
    return
10403 
 
10404 
 
10405 
  def __repr__(self):
10406 
    L = ['%s=%r' % (key, value)
10407 
      for key, value in self.__dict__.iteritems()]
10408 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10409 
 
10410 
  def __eq__(self, other):
10411 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10412 
 
10413 
  def __ne__(self, other):
10414 
    return not (self == other)
10415 
 
10416 
class deleteItemFromIgnoredInventoryUpdateList_result:
10417 
  """
10418 
  Attributes:
10419 
   - success
10420 
  """
10421 
 
10422 
  thrift_spec = (
10423 
    (0, TType.BOOL, 'success', None, None, ), # 0
10424 
  )
10425 
 
10426 
  def __init__(self, success=None,):
10427 
    self.success = success
10428 
 
10429 
  def read(self, iprot):
10430 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10431 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10432 
      return
10433 
    iprot.readStructBegin()
10434 
    while True:
10435 
      (fname, ftype, fid) = iprot.readFieldBegin()
10436 
      if ftype == TType.STOP:
10437 
        break
10438 
      if fid == 0:
10439 
        if ftype == TType.BOOL:
10440 
          self.success = iprot.readBool();
10441 
        else:
10442 
          iprot.skip(ftype)
10443 
      else:
10444 
        iprot.skip(ftype)
10445 
      iprot.readFieldEnd()
10446 
    iprot.readStructEnd()
10447 
 
10448 
  def write(self, oprot):
10449 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10450 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10451 
      return
10452 
    oprot.writeStructBegin('deleteItemFromIgnoredInventoryUpdateList_result')
10453 
    if self.success is not None:
10454 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10455 
      oprot.writeBool(self.success)
10456 
      oprot.writeFieldEnd()
10457 
    oprot.writeFieldStop()
10458 
    oprot.writeStructEnd()
10459 
 
10460 
  def validate(self):
10461 
    return
10462 
 
10463 
 
10464 
  def __repr__(self):
10465 
    L = ['%s=%r' % (key, value)
10466 
      for key, value in self.__dict__.iteritems()]
10467 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10468 
 
10469 
  def __eq__(self, other):
10470 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10471 
 
10472 
  def __ne__(self, other):
10473 
    return not (self == other)
10474 
 
10475 
class getAllIgnoredInventoryupdateItemsCount_args:
10476 
 
10477 
  thrift_spec = (
10478 
  )
10479 
 
10480 
  def read(self, iprot):
10481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10483 
      return
10484 
    iprot.readStructBegin()
10485 
    while True:
10486 
      (fname, ftype, fid) = iprot.readFieldBegin()
10487 
      if ftype == TType.STOP:
10488 
        break
10489 
      else:
10490 
        iprot.skip(ftype)
10491 
      iprot.readFieldEnd()
10492 
    iprot.readStructEnd()
10493 
 
10494 
  def write(self, oprot):
10495 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10496 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10497 
      return
10498 
    oprot.writeStructBegin('getAllIgnoredInventoryupdateItemsCount_args')
10499 
    oprot.writeFieldStop()
10500 
    oprot.writeStructEnd()
10501 
 
10502 
  def validate(self):
10503 
    return
10504 
 
10505 
 
10506 
  def __repr__(self):
10507 
    L = ['%s=%r' % (key, value)
10508 
      for key, value in self.__dict__.iteritems()]
10509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10510 
 
10511 
  def __eq__(self, other):
10512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10513 
 
10514 
  def __ne__(self, other):
10515 
    return not (self == other)
10516 
 
10517 
class getAllIgnoredInventoryupdateItemsCount_result:
10518 
  """
10519 
  Attributes:
10520 
   - success
10521 
  """
10522 
 
10523 
  thrift_spec = (
10524 
    (0, TType.I32, 'success', None, None, ), # 0
10525 
  )
10526 
 
10527 
  def __init__(self, success=None,):
10528 
    self.success = success
10529 
 
10530 
  def read(self, iprot):
10531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10533 
      return
10534 
    iprot.readStructBegin()
10535 
    while True:
10536 
      (fname, ftype, fid) = iprot.readFieldBegin()
10537 
      if ftype == TType.STOP:
10538 
        break
10539 
      if fid == 0:
10540 
        if ftype == TType.I32:
10541 
          self.success = iprot.readI32();
10542 
        else:
10543 
          iprot.skip(ftype)
10544 
      else:
10545 
        iprot.skip(ftype)
10546 
      iprot.readFieldEnd()
10547 
    iprot.readStructEnd()
10548 
 
10549 
  def write(self, oprot):
10550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10552 
      return
10553 
    oprot.writeStructBegin('getAllIgnoredInventoryupdateItemsCount_result')
10554 
    if self.success is not None:
10555 
      oprot.writeFieldBegin('success', TType.I32, 0)
10556 
      oprot.writeI32(self.success)
10557 
      oprot.writeFieldEnd()
10558 
    oprot.writeFieldStop()
10559 
    oprot.writeStructEnd()
10560 
 
10561 
  def validate(self):
10562 
    return
10563 
 
10564 
 
10565 
  def __repr__(self):
10566 
    L = ['%s=%r' % (key, value)
10567 
      for key, value in self.__dict__.iteritems()]
10568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10569 
 
10570 
  def __eq__(self, other):
10571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10572 
 
10573 
  def __ne__(self, other):
10574 
    return not (self == other)
10575 
 
10576 
class getIgnoredInventoryUpdateItemids_args:
10577 
  """
10578 
  Attributes:
10579 
   - offset
10580 
   - limit
10581 
  """
10582 
 
10583 
  thrift_spec = (
10584 
    None, # 0
10585 
    (1, TType.I32, 'offset', None, None, ), # 1
10586 
    (2, TType.I32, 'limit', None, None, ), # 2
10587 
  )
10588 
 
10589 
  def __init__(self, offset=None, limit=None,):
10590 
    self.offset = offset
10591 
    self.limit = limit
10592 
 
10593 
  def read(self, iprot):
10594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10596 
      return
10597 
    iprot.readStructBegin()
10598 
    while True:
10599 
      (fname, ftype, fid) = iprot.readFieldBegin()
10600 
      if ftype == TType.STOP:
10601 
        break
10602 
      if fid == 1:
10603 
        if ftype == TType.I32:
10604 
          self.offset = iprot.readI32();
10605 
        else:
10606 
          iprot.skip(ftype)
10607 
      elif fid == 2:
10608 
        if ftype == TType.I32:
10609 
          self.limit = iprot.readI32();
10610 
        else:
10611 
          iprot.skip(ftype)
10612 
      else:
10613 
        iprot.skip(ftype)
10614 
      iprot.readFieldEnd()
10615 
    iprot.readStructEnd()
10616 
 
10617 
  def write(self, oprot):
10618 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10619 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10620 
      return
10621 
    oprot.writeStructBegin('getIgnoredInventoryUpdateItemids_args')
10622 
    if self.offset is not None:
10623 
      oprot.writeFieldBegin('offset', TType.I32, 1)
10624 
      oprot.writeI32(self.offset)
10625 
      oprot.writeFieldEnd()
10626 
    if self.limit is not None:
10627 
      oprot.writeFieldBegin('limit', TType.I32, 2)
10628 
      oprot.writeI32(self.limit)
10629 
      oprot.writeFieldEnd()
10630 
    oprot.writeFieldStop()
10631 
    oprot.writeStructEnd()
10632 
 
10633 
  def validate(self):
10634 
    return
10635 
 
10636 
 
10637 
  def __repr__(self):
10638 
    L = ['%s=%r' % (key, value)
10639 
      for key, value in self.__dict__.iteritems()]
10640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10641 
 
10642 
  def __eq__(self, other):
10643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10644 
 
10645 
  def __ne__(self, other):
10646 
    return not (self == other)
10647 
 
10648 
class getIgnoredInventoryUpdateItemids_result:
10649 
  """
10650 
  Attributes:
10651 
   - success
10652 
  """
10653 
 
10654 
  thrift_spec = (
10655 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10656 
  )
10657 
 
10658 
  def __init__(self, success=None,):
10659 
    self.success = success
10660 
 
10661 
  def read(self, iprot):
10662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10664 
      return
10665 
    iprot.readStructBegin()
10666 
    while True:
10667 
      (fname, ftype, fid) = iprot.readFieldBegin()
10668 
      if ftype == TType.STOP:
10669 
        break
10670 
      if fid == 0:
10671 
        if ftype == TType.LIST:
10672 
          self.success = []
8182 amar.kumar 10673 
          (_etype189, _size186) = iprot.readListBegin()
10674 
          for _i190 in xrange(_size186):
10675 
            _elem191 = iprot.readI64();
10676 
            self.success.append(_elem191)
6531 vikram.rag 10677 
          iprot.readListEnd()
10678 
        else:
10679 
          iprot.skip(ftype)
10680 
      else:
10681 
        iprot.skip(ftype)
10682 
      iprot.readFieldEnd()
10683 
    iprot.readStructEnd()
10684 
 
10685 
  def write(self, oprot):
10686 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10687 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10688 
      return
10689 
    oprot.writeStructBegin('getIgnoredInventoryUpdateItemids_result')
10690 
    if self.success is not None:
10691 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10692 
      oprot.writeListBegin(TType.I64, len(self.success))
8182 amar.kumar 10693 
      for iter192 in self.success:
10694 
        oprot.writeI64(iter192)
6531 vikram.rag 10695 
      oprot.writeListEnd()
10696 
      oprot.writeFieldEnd()
10697 
    oprot.writeFieldStop()
10698 
    oprot.writeStructEnd()
10699 
 
10700 
  def validate(self):
10701 
    return
10702 
 
10703 
 
10704 
  def __repr__(self):
10705 
    L = ['%s=%r' % (key, value)
10706 
      for key, value in self.__dict__.iteritems()]
10707 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10708 
 
10709 
  def __eq__(self, other):
10710 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10711 
 
10712 
  def __ne__(self, other):
10713 
    return not (self == other)
6821 amar.kumar 10714 
 
10715 
class updateItemStockPurchaseParams_args:
10716 
  """
10717 
  Attributes:
10718 
   - item_id
10719 
   - numOfDaysStock
10720 
   - minStockLevel
10721 
  """
10722 
 
10723 
  thrift_spec = (
10724 
    None, # 0
10725 
    (1, TType.I64, 'item_id', None, None, ), # 1
10726 
    (2, TType.I32, 'numOfDaysStock', None, None, ), # 2
10727 
    (3, TType.I64, 'minStockLevel', None, None, ), # 3
10728 
  )
10729 
 
10730 
  def __init__(self, item_id=None, numOfDaysStock=None, minStockLevel=None,):
10731 
    self.item_id = item_id
10732 
    self.numOfDaysStock = numOfDaysStock
10733 
    self.minStockLevel = minStockLevel
10734 
 
10735 
  def read(self, iprot):
10736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10738 
      return
10739 
    iprot.readStructBegin()
10740 
    while True:
10741 
      (fname, ftype, fid) = iprot.readFieldBegin()
10742 
      if ftype == TType.STOP:
10743 
        break
10744 
      if fid == 1:
10745 
        if ftype == TType.I64:
10746 
          self.item_id = iprot.readI64();
10747 
        else:
10748 
          iprot.skip(ftype)
10749 
      elif fid == 2:
10750 
        if ftype == TType.I32:
10751 
          self.numOfDaysStock = iprot.readI32();
10752 
        else:
10753 
          iprot.skip(ftype)
10754 
      elif fid == 3:
10755 
        if ftype == TType.I64:
10756 
          self.minStockLevel = iprot.readI64();
10757 
        else:
10758 
          iprot.skip(ftype)
10759 
      else:
10760 
        iprot.skip(ftype)
10761 
      iprot.readFieldEnd()
10762 
    iprot.readStructEnd()
10763 
 
10764 
  def write(self, oprot):
10765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10767 
      return
10768 
    oprot.writeStructBegin('updateItemStockPurchaseParams_args')
10769 
    if self.item_id is not None:
10770 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
10771 
      oprot.writeI64(self.item_id)
10772 
      oprot.writeFieldEnd()
10773 
    if self.numOfDaysStock is not None:
10774 
      oprot.writeFieldBegin('numOfDaysStock', TType.I32, 2)
10775 
      oprot.writeI32(self.numOfDaysStock)
10776 
      oprot.writeFieldEnd()
10777 
    if self.minStockLevel is not None:
10778 
      oprot.writeFieldBegin('minStockLevel', TType.I64, 3)
10779 
      oprot.writeI64(self.minStockLevel)
10780 
      oprot.writeFieldEnd()
10781 
    oprot.writeFieldStop()
10782 
    oprot.writeStructEnd()
10783 
 
10784 
  def validate(self):
10785 
    return
10786 
 
10787 
 
10788 
  def __repr__(self):
10789 
    L = ['%s=%r' % (key, value)
10790 
      for key, value in self.__dict__.iteritems()]
10791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10792 
 
10793 
  def __eq__(self, other):
10794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10795 
 
10796 
  def __ne__(self, other):
10797 
    return not (self == other)
10798 
 
10799 
class updateItemStockPurchaseParams_result:
10800 
 
10801 
  thrift_spec = (
10802 
  )
10803 
 
10804 
  def read(self, iprot):
10805 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10806 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10807 
      return
10808 
    iprot.readStructBegin()
10809 
    while True:
10810 
      (fname, ftype, fid) = iprot.readFieldBegin()
10811 
      if ftype == TType.STOP:
10812 
        break
10813 
      else:
10814 
        iprot.skip(ftype)
10815 
      iprot.readFieldEnd()
10816 
    iprot.readStructEnd()
10817 
 
10818 
  def write(self, oprot):
10819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10821 
      return
10822 
    oprot.writeStructBegin('updateItemStockPurchaseParams_result')
10823 
    oprot.writeFieldStop()
10824 
    oprot.writeStructEnd()
10825 
 
10826 
  def validate(self):
10827 
    return
10828 
 
10829 
 
10830 
  def __repr__(self):
10831 
    L = ['%s=%r' % (key, value)
10832 
      for key, value in self.__dict__.iteritems()]
10833 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10834 
 
10835 
  def __eq__(self, other):
10836 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10837 
 
10838 
  def __ne__(self, other):
10839 
    return not (self == other)
10840 
 
10841 
class getItemStockPurchaseParams_args:
10842 
  """
10843 
  Attributes:
10844 
   - itemId
10845 
  """
10846 
 
10847 
  thrift_spec = (
10848 
    None, # 0
10849 
    (1, TType.I64, 'itemId', None, None, ), # 1
10850 
  )
10851 
 
10852 
  def __init__(self, itemId=None,):
10853 
    self.itemId = itemId
10854 
 
10855 
  def read(self, iprot):
10856 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10857 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10858 
      return
10859 
    iprot.readStructBegin()
10860 
    while True:
10861 
      (fname, ftype, fid) = iprot.readFieldBegin()
10862 
      if ftype == TType.STOP:
10863 
        break
10864 
      if fid == 1:
10865 
        if ftype == TType.I64:
10866 
          self.itemId = iprot.readI64();
10867 
        else:
10868 
          iprot.skip(ftype)
10869 
      else:
10870 
        iprot.skip(ftype)
10871 
      iprot.readFieldEnd()
10872 
    iprot.readStructEnd()
10873 
 
10874 
  def write(self, oprot):
10875 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10876 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10877 
      return
10878 
    oprot.writeStructBegin('getItemStockPurchaseParams_args')
10879 
    if self.itemId is not None:
10880 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
10881 
      oprot.writeI64(self.itemId)
10882 
      oprot.writeFieldEnd()
10883 
    oprot.writeFieldStop()
10884 
    oprot.writeStructEnd()
10885 
 
10886 
  def validate(self):
10887 
    return
10888 
 
10889 
 
10890 
  def __repr__(self):
10891 
    L = ['%s=%r' % (key, value)
10892 
      for key, value in self.__dict__.iteritems()]
10893 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10894 
 
10895 
  def __eq__(self, other):
10896 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10897 
 
10898 
  def __ne__(self, other):
10899 
    return not (self == other)
10900 
 
10901 
class getItemStockPurchaseParams_result:
10902 
  """
10903 
  Attributes:
10904 
   - success
10905 
  """
10906 
 
10907 
  thrift_spec = (
10908 
    (0, TType.STRUCT, 'success', (ItemStockPurchaseParams, ItemStockPurchaseParams.thrift_spec), None, ), # 0
10909 
  )
10910 
 
10911 
  def __init__(self, success=None,):
10912 
    self.success = success
10913 
 
10914 
  def read(self, iprot):
10915 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10916 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10917 
      return
10918 
    iprot.readStructBegin()
10919 
    while True:
10920 
      (fname, ftype, fid) = iprot.readFieldBegin()
10921 
      if ftype == TType.STOP:
10922 
        break
10923 
      if fid == 0:
10924 
        if ftype == TType.STRUCT:
10925 
          self.success = ItemStockPurchaseParams()
10926 
          self.success.read(iprot)
10927 
        else:
10928 
          iprot.skip(ftype)
10929 
      else:
10930 
        iprot.skip(ftype)
10931 
      iprot.readFieldEnd()
10932 
    iprot.readStructEnd()
10933 
 
10934 
  def write(self, oprot):
10935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10937 
      return
10938 
    oprot.writeStructBegin('getItemStockPurchaseParams_result')
10939 
    if self.success is not None:
10940 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10941 
      self.success.write(oprot)
10942 
      oprot.writeFieldEnd()
10943 
    oprot.writeFieldStop()
10944 
    oprot.writeStructEnd()
10945 
 
10946 
  def validate(self):
10947 
    return
10948 
 
10949 
 
10950 
  def __repr__(self):
10951 
    L = ['%s=%r' % (key, value)
10952 
      for key, value in self.__dict__.iteritems()]
10953 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10954 
 
10955 
  def __eq__(self, other):
10956 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10957 
 
10958 
  def __ne__(self, other):
10959 
    return not (self == other)
10960 
 
10961 
class addOosStatusForItem_args:
10962 
  """
10963 
  Attributes:
10964 
   - oosStatusMap
10965 
   - date
10966 
  """
10967 
 
10968 
  thrift_spec = (
10969 
    None, # 0
10970 
    (1, TType.MAP, 'oosStatusMap', (TType.I64,None,TType.BOOL,None), None, ), # 1
10971 
    (2, TType.I64, 'date', None, None, ), # 2
10972 
  )
10973 
 
10974 
  def __init__(self, oosStatusMap=None, date=None,):
10975 
    self.oosStatusMap = oosStatusMap
10976 
    self.date = date
10977 
 
10978 
  def read(self, iprot):
10979 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10980 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10981 
      return
10982 
    iprot.readStructBegin()
10983 
    while True:
10984 
      (fname, ftype, fid) = iprot.readFieldBegin()
10985 
      if ftype == TType.STOP:
10986 
        break
10987 
      if fid == 1:
10988 
        if ftype == TType.MAP:
10989 
          self.oosStatusMap = {}
8182 amar.kumar 10990 
          (_ktype194, _vtype195, _size193 ) = iprot.readMapBegin()
10991 
          for _i197 in xrange(_size193):
10992 
            _key198 = iprot.readI64();
10993 
            _val199 = iprot.readBool();
10994 
            self.oosStatusMap[_key198] = _val199
6821 amar.kumar 10995 
          iprot.readMapEnd()
10996 
        else:
10997 
          iprot.skip(ftype)
10998 
      elif fid == 2:
10999 
        if ftype == TType.I64:
11000 
          self.date = iprot.readI64();
11001 
        else:
11002 
          iprot.skip(ftype)
11003 
      else:
11004 
        iprot.skip(ftype)
11005 
      iprot.readFieldEnd()
11006 
    iprot.readStructEnd()
11007 
 
11008 
  def write(self, oprot):
11009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11011 
      return
11012 
    oprot.writeStructBegin('addOosStatusForItem_args')
11013 
    if self.oosStatusMap is not None:
11014 
      oprot.writeFieldBegin('oosStatusMap', TType.MAP, 1)
11015 
      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.oosStatusMap))
8182 amar.kumar 11016 
      for kiter200,viter201 in self.oosStatusMap.items():
11017 
        oprot.writeI64(kiter200)
11018 
        oprot.writeBool(viter201)
6821 amar.kumar 11019 
      oprot.writeMapEnd()
11020 
      oprot.writeFieldEnd()
11021 
    if self.date is not None:
11022 
      oprot.writeFieldBegin('date', TType.I64, 2)
11023 
      oprot.writeI64(self.date)
11024 
      oprot.writeFieldEnd()
11025 
    oprot.writeFieldStop()
11026 
    oprot.writeStructEnd()
11027 
 
11028 
  def validate(self):
11029 
    return
11030 
 
11031 
 
11032 
  def __repr__(self):
11033 
    L = ['%s=%r' % (key, value)
11034 
      for key, value in self.__dict__.iteritems()]
11035 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11036 
 
11037 
  def __eq__(self, other):
11038 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11039 
 
11040 
  def __ne__(self, other):
11041 
    return not (self == other)
11042 
 
11043 
class addOosStatusForItem_result:
11044 
 
11045 
  thrift_spec = (
11046 
  )
11047 
 
11048 
  def read(self, iprot):
11049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11051 
      return
11052 
    iprot.readStructBegin()
11053 
    while True:
11054 
      (fname, ftype, fid) = iprot.readFieldBegin()
11055 
      if ftype == TType.STOP:
11056 
        break
11057 
      else:
11058 
        iprot.skip(ftype)
11059 
      iprot.readFieldEnd()
11060 
    iprot.readStructEnd()
11061 
 
11062 
  def write(self, oprot):
11063 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11064 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11065 
      return
11066 
    oprot.writeStructBegin('addOosStatusForItem_result')
11067 
    oprot.writeFieldStop()
11068 
    oprot.writeStructEnd()
11069 
 
11070 
  def validate(self):
11071 
    return
11072 
 
11073 
 
11074 
  def __repr__(self):
11075 
    L = ['%s=%r' % (key, value)
11076 
      for key, value in self.__dict__.iteritems()]
11077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11078 
 
11079 
  def __eq__(self, other):
11080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11081 
 
11082 
  def __ne__(self, other):
11083 
    return not (self == other)
6832 amar.kumar 11084 
 
11085 
class getOosStatusesForXDaysForItem_args:
11086 
  """
11087 
  Attributes:
11088 
   - itemId
9762 amar.kumar 11089 
   - sourceId
6832 amar.kumar 11090 
   - days
11091 
  """
11092 
 
11093 
  thrift_spec = (
11094 
    None, # 0
11095 
    (1, TType.I64, 'itemId', None, None, ), # 1
9762 amar.kumar 11096 
    (2, TType.I32, 'sourceId', None, None, ), # 2
11097 
    (3, TType.I32, 'days', None, None, ), # 3
6832 amar.kumar 11098 
  )
11099 
 
9762 amar.kumar 11100 
  def __init__(self, itemId=None, sourceId=None, days=None,):
6832 amar.kumar 11101 
    self.itemId = itemId
9762 amar.kumar 11102 
    self.sourceId = sourceId
6832 amar.kumar 11103 
    self.days = days
11104 
 
11105 
  def read(self, iprot):
11106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11108 
      return
11109 
    iprot.readStructBegin()
11110 
    while True:
11111 
      (fname, ftype, fid) = iprot.readFieldBegin()
11112 
      if ftype == TType.STOP:
11113 
        break
11114 
      if fid == 1:
11115 
        if ftype == TType.I64:
11116 
          self.itemId = iprot.readI64();
11117 
        else:
11118 
          iprot.skip(ftype)
11119 
      elif fid == 2:
11120 
        if ftype == TType.I32:
9762 amar.kumar 11121 
          self.sourceId = iprot.readI32();
11122 
        else:
11123 
          iprot.skip(ftype)
11124 
      elif fid == 3:
11125 
        if ftype == TType.I32:
6832 amar.kumar 11126 
          self.days = iprot.readI32();
11127 
        else:
11128 
          iprot.skip(ftype)
11129 
      else:
11130 
        iprot.skip(ftype)
11131 
      iprot.readFieldEnd()
11132 
    iprot.readStructEnd()
11133 
 
11134 
  def write(self, oprot):
11135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11137 
      return
11138 
    oprot.writeStructBegin('getOosStatusesForXDaysForItem_args')
11139 
    if self.itemId is not None:
11140 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11141 
      oprot.writeI64(self.itemId)
11142 
      oprot.writeFieldEnd()
9762 amar.kumar 11143 
    if self.sourceId is not None:
11144 
      oprot.writeFieldBegin('sourceId', TType.I32, 2)
11145 
      oprot.writeI32(self.sourceId)
11146 
      oprot.writeFieldEnd()
6832 amar.kumar 11147 
    if self.days is not None:
9762 amar.kumar 11148 
      oprot.writeFieldBegin('days', TType.I32, 3)
6832 amar.kumar 11149 
      oprot.writeI32(self.days)
11150 
      oprot.writeFieldEnd()
11151 
    oprot.writeFieldStop()
11152 
    oprot.writeStructEnd()
11153 
 
11154 
  def validate(self):
11155 
    return
11156 
 
11157 
 
11158 
  def __repr__(self):
11159 
    L = ['%s=%r' % (key, value)
11160 
      for key, value in self.__dict__.iteritems()]
11161 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11162 
 
11163 
  def __eq__(self, other):
11164 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11165 
 
11166 
  def __ne__(self, other):
11167 
    return not (self == other)
11168 
 
11169 
class getOosStatusesForXDaysForItem_result:
11170 
  """
11171 
  Attributes:
11172 
   - success
11173 
  """
11174 
 
11175 
  thrift_spec = (
11176 
    (0, TType.LIST, 'success', (TType.STRUCT,(OOSStatus, OOSStatus.thrift_spec)), None, ), # 0
11177 
  )
11178 
 
11179 
  def __init__(self, success=None,):
11180 
    self.success = success
11181 
 
11182 
  def read(self, iprot):
11183 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11184 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11185 
      return
11186 
    iprot.readStructBegin()
11187 
    while True:
11188 
      (fname, ftype, fid) = iprot.readFieldBegin()
11189 
      if ftype == TType.STOP:
11190 
        break
11191 
      if fid == 0:
11192 
        if ftype == TType.LIST:
11193 
          self.success = []
8182 amar.kumar 11194 
          (_etype205, _size202) = iprot.readListBegin()
11195 
          for _i206 in xrange(_size202):
11196 
            _elem207 = OOSStatus()
11197 
            _elem207.read(iprot)
11198 
            self.success.append(_elem207)
6832 amar.kumar 11199 
          iprot.readListEnd()
11200 
        else:
11201 
          iprot.skip(ftype)
11202 
      else:
11203 
        iprot.skip(ftype)
11204 
      iprot.readFieldEnd()
11205 
    iprot.readStructEnd()
11206 
 
11207 
  def write(self, oprot):
11208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11210 
      return
11211 
    oprot.writeStructBegin('getOosStatusesForXDaysForItem_result')
11212 
    if self.success is not None:
11213 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11214 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 11215 
      for iter208 in self.success:
11216 
        iter208.write(oprot)
6832 amar.kumar 11217 
      oprot.writeListEnd()
11218 
      oprot.writeFieldEnd()
11219 
    oprot.writeFieldStop()
11220 
    oprot.writeStructEnd()
11221 
 
11222 
  def validate(self):
11223 
    return
11224 
 
11225 
 
11226 
  def __repr__(self):
11227 
    L = ['%s=%r' % (key, value)
11228 
      for key, value in self.__dict__.iteritems()]
11229 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11230 
 
11231 
  def __eq__(self, other):
11232 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11233 
 
11234 
  def __ne__(self, other):
11235 
    return not (self == other)
6857 amar.kumar 11236 
 
10126 amar.kumar 11237 
class getOosStatusesForXDays_args:
11238 
  """
11239 
  Attributes:
11240 
   - sourceId
11241 
   - days
11242 
  """
6857 amar.kumar 11243 
 
11244 
  thrift_spec = (
10126 amar.kumar 11245 
    None, # 0
11246 
    (1, TType.I32, 'sourceId', None, None, ), # 1
11247 
    (2, TType.I32, 'days', None, None, ), # 2
6857 amar.kumar 11248 
  )
11249 
 
10126 amar.kumar 11250 
  def __init__(self, sourceId=None, days=None,):
11251 
    self.sourceId = sourceId
11252 
    self.days = days
11253 
 
6857 amar.kumar 11254 
  def read(self, iprot):
11255 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11256 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11257 
      return
11258 
    iprot.readStructBegin()
11259 
    while True:
11260 
      (fname, ftype, fid) = iprot.readFieldBegin()
11261 
      if ftype == TType.STOP:
11262 
        break
10126 amar.kumar 11263 
      if fid == 1:
11264 
        if ftype == TType.I32:
11265 
          self.sourceId = iprot.readI32();
11266 
        else:
11267 
          iprot.skip(ftype)
11268 
      elif fid == 2:
11269 
        if ftype == TType.I32:
11270 
          self.days = iprot.readI32();
11271 
        else:
11272 
          iprot.skip(ftype)
6857 amar.kumar 11273 
      else:
11274 
        iprot.skip(ftype)
11275 
      iprot.readFieldEnd()
11276 
    iprot.readStructEnd()
11277 
 
11278 
  def write(self, oprot):
11279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11281 
      return
10126 amar.kumar 11282 
    oprot.writeStructBegin('getOosStatusesForXDays_args')
11283 
    if self.sourceId is not None:
11284 
      oprot.writeFieldBegin('sourceId', TType.I32, 1)
11285 
      oprot.writeI32(self.sourceId)
11286 
      oprot.writeFieldEnd()
11287 
    if self.days is not None:
11288 
      oprot.writeFieldBegin('days', TType.I32, 2)
11289 
      oprot.writeI32(self.days)
11290 
      oprot.writeFieldEnd()
6857 amar.kumar 11291 
    oprot.writeFieldStop()
11292 
    oprot.writeStructEnd()
11293 
 
11294 
  def validate(self):
11295 
    return
11296 
 
11297 
 
11298 
  def __repr__(self):
11299 
    L = ['%s=%r' % (key, value)
11300 
      for key, value in self.__dict__.iteritems()]
11301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11302 
 
11303 
  def __eq__(self, other):
11304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11305 
 
11306 
  def __ne__(self, other):
11307 
    return not (self == other)
11308 
 
10126 amar.kumar 11309 
class getOosStatusesForXDays_result:
6857 amar.kumar 11310 
  """
11311 
  Attributes:
11312 
   - success
11313 
  """
11314 
 
11315 
  thrift_spec = (
10126 amar.kumar 11316 
    (0, TType.LIST, 'success', (TType.STRUCT,(OOSStatus, OOSStatus.thrift_spec)), None, ), # 0
6857 amar.kumar 11317 
  )
11318 
 
11319 
  def __init__(self, success=None,):
11320 
    self.success = success
11321 
 
11322 
  def read(self, iprot):
11323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11325 
      return
11326 
    iprot.readStructBegin()
11327 
    while True:
11328 
      (fname, ftype, fid) = iprot.readFieldBegin()
11329 
      if ftype == TType.STOP:
11330 
        break
11331 
      if fid == 0:
11332 
        if ftype == TType.LIST:
11333 
          self.success = []
8182 amar.kumar 11334 
          (_etype212, _size209) = iprot.readListBegin()
11335 
          for _i213 in xrange(_size209):
10126 amar.kumar 11336 
            _elem214 = OOSStatus()
8182 amar.kumar 11337 
            _elem214.read(iprot)
11338 
            self.success.append(_elem214)
6857 amar.kumar 11339 
          iprot.readListEnd()
11340 
        else:
11341 
          iprot.skip(ftype)
11342 
      else:
11343 
        iprot.skip(ftype)
11344 
      iprot.readFieldEnd()
11345 
    iprot.readStructEnd()
11346 
 
11347 
  def write(self, oprot):
11348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11350 
      return
10126 amar.kumar 11351 
    oprot.writeStructBegin('getOosStatusesForXDays_result')
6857 amar.kumar 11352 
    if self.success is not None:
11353 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11354 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 11355 
      for iter215 in self.success:
11356 
        iter215.write(oprot)
6857 amar.kumar 11357 
      oprot.writeListEnd()
11358 
      oprot.writeFieldEnd()
11359 
    oprot.writeFieldStop()
11360 
    oprot.writeStructEnd()
11361 
 
11362 
  def validate(self):
11363 
    return
11364 
 
11365 
 
11366 
  def __repr__(self):
11367 
    L = ['%s=%r' % (key, value)
11368 
      for key, value in self.__dict__.iteritems()]
11369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11370 
 
11371 
  def __eq__(self, other):
11372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11373 
 
11374 
  def __ne__(self, other):
11375 
    return not (self == other)
7149 amar.kumar 11376 
 
10126 amar.kumar 11377 
class getAllVendorItemPricing_args:
11378 
  """
11379 
  Attributes:
11380 
   - itemId
11381 
   - vendorId
11382 
  """
7149 amar.kumar 11383 
 
11384 
  thrift_spec = (
10126 amar.kumar 11385 
    None, # 0
11386 
    (1, TType.I64, 'itemId', None, None, ), # 1
11387 
    (2, TType.I64, 'vendorId', None, None, ), # 2
7149 amar.kumar 11388 
  )
11389 
 
10126 amar.kumar 11390 
  def __init__(self, itemId=None, vendorId=None,):
11391 
    self.itemId = itemId
11392 
    self.vendorId = vendorId
11393 
 
7149 amar.kumar 11394 
  def read(self, iprot):
11395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11397 
      return
11398 
    iprot.readStructBegin()
11399 
    while True:
11400 
      (fname, ftype, fid) = iprot.readFieldBegin()
11401 
      if ftype == TType.STOP:
11402 
        break
10126 amar.kumar 11403 
      if fid == 1:
11404 
        if ftype == TType.I64:
11405 
          self.itemId = iprot.readI64();
11406 
        else:
11407 
          iprot.skip(ftype)
11408 
      elif fid == 2:
11409 
        if ftype == TType.I64:
11410 
          self.vendorId = iprot.readI64();
11411 
        else:
11412 
          iprot.skip(ftype)
7149 amar.kumar 11413 
      else:
11414 
        iprot.skip(ftype)
11415 
      iprot.readFieldEnd()
11416 
    iprot.readStructEnd()
11417 
 
11418 
  def write(self, oprot):
11419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11421 
      return
10126 amar.kumar 11422 
    oprot.writeStructBegin('getAllVendorItemPricing_args')
11423 
    if self.itemId is not None:
11424 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11425 
      oprot.writeI64(self.itemId)
11426 
      oprot.writeFieldEnd()
11427 
    if self.vendorId is not None:
11428 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
11429 
      oprot.writeI64(self.vendorId)
11430 
      oprot.writeFieldEnd()
7149 amar.kumar 11431 
    oprot.writeFieldStop()
11432 
    oprot.writeStructEnd()
11433 
 
11434 
  def validate(self):
11435 
    return
11436 
 
11437 
 
11438 
  def __repr__(self):
11439 
    L = ['%s=%r' % (key, value)
11440 
      for key, value in self.__dict__.iteritems()]
11441 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11442 
 
11443 
  def __eq__(self, other):
11444 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11445 
 
11446 
  def __ne__(self, other):
11447 
    return not (self == other)
11448 
 
10126 amar.kumar 11449 
class getAllVendorItemPricing_result:
7149 amar.kumar 11450 
  """
11451 
  Attributes:
11452 
   - success
11453 
  """
11454 
 
11455 
  thrift_spec = (
10126 amar.kumar 11456 
    (0, TType.LIST, 'success', (TType.STRUCT,(VendorItemPricing, VendorItemPricing.thrift_spec)), None, ), # 0
7149 amar.kumar 11457 
  )
11458 
 
11459 
  def __init__(self, success=None,):
11460 
    self.success = success
11461 
 
11462 
  def read(self, iprot):
11463 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11464 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11465 
      return
11466 
    iprot.readStructBegin()
11467 
    while True:
11468 
      (fname, ftype, fid) = iprot.readFieldBegin()
11469 
      if ftype == TType.STOP:
11470 
        break
11471 
      if fid == 0:
11472 
        if ftype == TType.LIST:
11473 
          self.success = []
8182 amar.kumar 11474 
          (_etype219, _size216) = iprot.readListBegin()
11475 
          for _i220 in xrange(_size216):
10126 amar.kumar 11476 
            _elem221 = VendorItemPricing()
8182 amar.kumar 11477 
            _elem221.read(iprot)
11478 
            self.success.append(_elem221)
7149 amar.kumar 11479 
          iprot.readListEnd()
11480 
        else:
11481 
          iprot.skip(ftype)
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
10126 amar.kumar 11491 
    oprot.writeStructBegin('getAllVendorItemPricing_result')
7149 amar.kumar 11492 
    if self.success is not None:
11493 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11494 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 11495 
      for iter222 in self.success:
11496 
        iter222.write(oprot)
7149 amar.kumar 11497 
      oprot.writeListEnd()
11498 
      oprot.writeFieldEnd()
11499 
    oprot.writeFieldStop()
11500 
    oprot.writeStructEnd()
11501 
 
11502 
  def validate(self):
11503 
    return
11504 
 
11505 
 
11506 
  def __repr__(self):
11507 
    L = ['%s=%r' % (key, value)
11508 
      for key, value in self.__dict__.iteritems()]
11509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11510 
 
11511 
  def __eq__(self, other):
11512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11513 
 
11514 
  def __ne__(self, other):
11515 
    return not (self == other)
7281 kshitij.so 11516 
 
10126 amar.kumar 11517 
class getNonZeroItemStockPurchaseParams_args:
11518 
 
11519 
  thrift_spec = (
11520 
  )
11521 
 
11522 
  def read(self, iprot):
11523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11525 
      return
11526 
    iprot.readStructBegin()
11527 
    while True:
11528 
      (fname, ftype, fid) = iprot.readFieldBegin()
11529 
      if ftype == TType.STOP:
11530 
        break
11531 
      else:
11532 
        iprot.skip(ftype)
11533 
      iprot.readFieldEnd()
11534 
    iprot.readStructEnd()
11535 
 
11536 
  def write(self, oprot):
11537 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11538 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11539 
      return
11540 
    oprot.writeStructBegin('getNonZeroItemStockPurchaseParams_args')
11541 
    oprot.writeFieldStop()
11542 
    oprot.writeStructEnd()
11543 
 
11544 
  def validate(self):
11545 
    return
11546 
 
11547 
 
11548 
  def __repr__(self):
11549 
    L = ['%s=%r' % (key, value)
11550 
      for key, value in self.__dict__.iteritems()]
11551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11552 
 
11553 
  def __eq__(self, other):
11554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11555 
 
11556 
  def __ne__(self, other):
11557 
    return not (self == other)
11558 
 
11559 
class getNonZeroItemStockPurchaseParams_result:
11560 
  """
11561 
  Attributes:
11562 
   - success
11563 
  """
11564 
 
11565 
  thrift_spec = (
11566 
    (0, TType.LIST, 'success', (TType.STRUCT,(ItemStockPurchaseParams, ItemStockPurchaseParams.thrift_spec)), None, ), # 0
11567 
  )
11568 
 
11569 
  def __init__(self, success=None,):
11570 
    self.success = success
11571 
 
11572 
  def read(self, iprot):
11573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11575 
      return
11576 
    iprot.readStructBegin()
11577 
    while True:
11578 
      (fname, ftype, fid) = iprot.readFieldBegin()
11579 
      if ftype == TType.STOP:
11580 
        break
11581 
      if fid == 0:
11582 
        if ftype == TType.LIST:
11583 
          self.success = []
11584 
          (_etype226, _size223) = iprot.readListBegin()
11585 
          for _i227 in xrange(_size223):
11586 
            _elem228 = ItemStockPurchaseParams()
11587 
            _elem228.read(iprot)
11588 
            self.success.append(_elem228)
11589 
          iprot.readListEnd()
11590 
        else:
11591 
          iprot.skip(ftype)
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('getNonZeroItemStockPurchaseParams_result')
11602 
    if self.success is not None:
11603 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11604 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11605 
      for iter229 in self.success:
11606 
        iter229.write(oprot)
11607 
      oprot.writeListEnd()
11608 
      oprot.writeFieldEnd()
11609 
    oprot.writeFieldStop()
11610 
    oprot.writeStructEnd()
11611 
 
11612 
  def validate(self):
11613 
    return
11614 
 
11615 
 
11616 
  def __repr__(self):
11617 
    L = ['%s=%r' % (key, value)
11618 
      for key, value in self.__dict__.iteritems()]
11619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11620 
 
11621 
  def __eq__(self, other):
11622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11623 
 
11624 
  def __ne__(self, other):
11625 
    return not (self == other)
11626 
 
11627 
class getBillableInventoryAndPendingOrders_args:
11628 
 
11629 
  thrift_spec = (
11630 
  )
11631 
 
11632 
  def read(self, iprot):
11633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11635 
      return
11636 
    iprot.readStructBegin()
11637 
    while True:
11638 
      (fname, ftype, fid) = iprot.readFieldBegin()
11639 
      if ftype == TType.STOP:
11640 
        break
11641 
      else:
11642 
        iprot.skip(ftype)
11643 
      iprot.readFieldEnd()
11644 
    iprot.readStructEnd()
11645 
 
11646 
  def write(self, oprot):
11647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11649 
      return
11650 
    oprot.writeStructBegin('getBillableInventoryAndPendingOrders_args')
11651 
    oprot.writeFieldStop()
11652 
    oprot.writeStructEnd()
11653 
 
11654 
  def validate(self):
11655 
    return
11656 
 
11657 
 
11658 
  def __repr__(self):
11659 
    L = ['%s=%r' % (key, value)
11660 
      for key, value in self.__dict__.iteritems()]
11661 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11662 
 
11663 
  def __eq__(self, other):
11664 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11665 
 
11666 
  def __ne__(self, other):
11667 
    return not (self == other)
11668 
 
11669 
class getBillableInventoryAndPendingOrders_result:
11670 
  """
11671 
  Attributes:
11672 
   - success
11673 
  """
11674 
 
11675 
  thrift_spec = (
11676 
    (0, TType.LIST, 'success', (TType.STRUCT,(AvailableAndReservedStock, AvailableAndReservedStock.thrift_spec)), None, ), # 0
11677 
  )
11678 
 
11679 
  def __init__(self, success=None,):
11680 
    self.success = success
11681 
 
11682 
  def read(self, iprot):
11683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11685 
      return
11686 
    iprot.readStructBegin()
11687 
    while True:
11688 
      (fname, ftype, fid) = iprot.readFieldBegin()
11689 
      if ftype == TType.STOP:
11690 
        break
11691 
      if fid == 0:
11692 
        if ftype == TType.LIST:
11693 
          self.success = []
11694 
          (_etype233, _size230) = iprot.readListBegin()
11695 
          for _i234 in xrange(_size230):
11696 
            _elem235 = AvailableAndReservedStock()
11697 
            _elem235.read(iprot)
11698 
            self.success.append(_elem235)
11699 
          iprot.readListEnd()
11700 
        else:
11701 
          iprot.skip(ftype)
11702 
      else:
11703 
        iprot.skip(ftype)
11704 
      iprot.readFieldEnd()
11705 
    iprot.readStructEnd()
11706 
 
11707 
  def write(self, oprot):
11708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11710 
      return
11711 
    oprot.writeStructBegin('getBillableInventoryAndPendingOrders_result')
11712 
    if self.success is not None:
11713 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11714 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11715 
      for iter236 in self.success:
11716 
        iter236.write(oprot)
11717 
      oprot.writeListEnd()
11718 
      oprot.writeFieldEnd()
11719 
    oprot.writeFieldStop()
11720 
    oprot.writeStructEnd()
11721 
 
11722 
  def validate(self):
11723 
    return
11724 
 
11725 
 
11726 
  def __repr__(self):
11727 
    L = ['%s=%r' % (key, value)
11728 
      for key, value in self.__dict__.iteritems()]
11729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11730 
 
11731 
  def __eq__(self, other):
11732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11733 
 
11734 
  def __ne__(self, other):
11735 
    return not (self == other)
11736 
 
7281 kshitij.so 11737 
class getWarehouseName_args:
11738 
  """
11739 
  Attributes:
11740 
   - warehouse_id
11741 
  """
11742 
 
11743 
  thrift_spec = (
11744 
    None, # 0
11745 
    (1, TType.I64, 'warehouse_id', None, None, ), # 1
11746 
  )
11747 
 
11748 
  def __init__(self, warehouse_id=None,):
11749 
    self.warehouse_id = warehouse_id
11750 
 
11751 
  def read(self, iprot):
11752 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11753 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11754 
      return
11755 
    iprot.readStructBegin()
11756 
    while True:
11757 
      (fname, ftype, fid) = iprot.readFieldBegin()
11758 
      if ftype == TType.STOP:
11759 
        break
11760 
      if fid == 1:
11761 
        if ftype == TType.I64:
11762 
          self.warehouse_id = iprot.readI64();
11763 
        else:
11764 
          iprot.skip(ftype)
11765 
      else:
11766 
        iprot.skip(ftype)
11767 
      iprot.readFieldEnd()
11768 
    iprot.readStructEnd()
11769 
 
11770 
  def write(self, oprot):
11771 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11772 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11773 
      return
11774 
    oprot.writeStructBegin('getWarehouseName_args')
11775 
    if self.warehouse_id is not None:
11776 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 1)
11777 
      oprot.writeI64(self.warehouse_id)
11778 
      oprot.writeFieldEnd()
11779 
    oprot.writeFieldStop()
11780 
    oprot.writeStructEnd()
11781 
 
11782 
  def validate(self):
11783 
    return
11784 
 
11785 
 
11786 
  def __repr__(self):
11787 
    L = ['%s=%r' % (key, value)
11788 
      for key, value in self.__dict__.iteritems()]
11789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11790 
 
11791 
  def __eq__(self, other):
11792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11793 
 
11794 
  def __ne__(self, other):
11795 
    return not (self == other)
11796 
 
11797 
class getWarehouseName_result:
11798 
  """
11799 
  Attributes:
11800 
   - success
11801 
  """
11802 
 
11803 
  thrift_spec = (
11804 
    (0, TType.STRING, 'success', None, None, ), # 0
11805 
  )
11806 
 
11807 
  def __init__(self, success=None,):
11808 
    self.success = success
11809 
 
11810 
  def read(self, iprot):
11811 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11812 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11813 
      return
11814 
    iprot.readStructBegin()
11815 
    while True:
11816 
      (fname, ftype, fid) = iprot.readFieldBegin()
11817 
      if ftype == TType.STOP:
11818 
        break
11819 
      if fid == 0:
11820 
        if ftype == TType.STRING:
11821 
          self.success = iprot.readString();
11822 
        else:
11823 
          iprot.skip(ftype)
11824 
      else:
11825 
        iprot.skip(ftype)
11826 
      iprot.readFieldEnd()
11827 
    iprot.readStructEnd()
11828 
 
11829 
  def write(self, oprot):
11830 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11831 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11832 
      return
11833 
    oprot.writeStructBegin('getWarehouseName_result')
11834 
    if self.success is not None:
11835 
      oprot.writeFieldBegin('success', TType.STRING, 0)
11836 
      oprot.writeString(self.success)
11837 
      oprot.writeFieldEnd()
11838 
    oprot.writeFieldStop()
11839 
    oprot.writeStructEnd()
11840 
 
11841 
  def validate(self):
11842 
    return
11843 
 
11844 
 
11845 
  def __repr__(self):
11846 
    L = ['%s=%r' % (key, value)
11847 
      for key, value in self.__dict__.iteritems()]
11848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11849 
 
11850 
  def __eq__(self, other):
11851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11852 
 
11853 
  def __ne__(self, other):
11854 
    return not (self == other)
11855 
 
11856 
class getAmazonInventoryForItem_args:
11857 
  """
11858 
  Attributes:
11859 
   - item_id
11860 
  """
11861 
 
11862 
  thrift_spec = (
11863 
    None, # 0
11864 
    (1, TType.I64, 'item_id', None, None, ), # 1
11865 
  )
11866 
 
11867 
  def __init__(self, item_id=None,):
11868 
    self.item_id = item_id
11869 
 
11870 
  def read(self, iprot):
11871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11873 
      return
11874 
    iprot.readStructBegin()
11875 
    while True:
11876 
      (fname, ftype, fid) = iprot.readFieldBegin()
11877 
      if ftype == TType.STOP:
11878 
        break
11879 
      if fid == 1:
11880 
        if ftype == TType.I64:
11881 
          self.item_id = iprot.readI64();
11882 
        else:
11883 
          iprot.skip(ftype)
11884 
      else:
11885 
        iprot.skip(ftype)
11886 
      iprot.readFieldEnd()
11887 
    iprot.readStructEnd()
11888 
 
11889 
  def write(self, oprot):
11890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11892 
      return
11893 
    oprot.writeStructBegin('getAmazonInventoryForItem_args')
11894 
    if self.item_id is not None:
11895 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
11896 
      oprot.writeI64(self.item_id)
11897 
      oprot.writeFieldEnd()
11898 
    oprot.writeFieldStop()
11899 
    oprot.writeStructEnd()
11900 
 
11901 
  def validate(self):
11902 
    return
11903 
 
11904 
 
11905 
  def __repr__(self):
11906 
    L = ['%s=%r' % (key, value)
11907 
      for key, value in self.__dict__.iteritems()]
11908 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11909 
 
11910 
  def __eq__(self, other):
11911 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11912 
 
11913 
  def __ne__(self, other):
11914 
    return not (self == other)
11915 
 
11916 
class getAmazonInventoryForItem_result:
11917 
  """
11918 
  Attributes:
11919 
   - success
11920 
  """
11921 
 
11922 
  thrift_spec = (
11923 
    (0, TType.STRUCT, 'success', (AmazonInventorySnapshot, AmazonInventorySnapshot.thrift_spec), None, ), # 0
11924 
  )
11925 
 
11926 
  def __init__(self, success=None,):
11927 
    self.success = success
11928 
 
11929 
  def read(self, iprot):
11930 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11931 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11932 
      return
11933 
    iprot.readStructBegin()
11934 
    while True:
11935 
      (fname, ftype, fid) = iprot.readFieldBegin()
11936 
      if ftype == TType.STOP:
11937 
        break
11938 
      if fid == 0:
11939 
        if ftype == TType.STRUCT:
11940 
          self.success = AmazonInventorySnapshot()
11941 
          self.success.read(iprot)
11942 
        else:
11943 
          iprot.skip(ftype)
11944 
      else:
11945 
        iprot.skip(ftype)
11946 
      iprot.readFieldEnd()
11947 
    iprot.readStructEnd()
11948 
 
11949 
  def write(self, oprot):
11950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11952 
      return
11953 
    oprot.writeStructBegin('getAmazonInventoryForItem_result')
11954 
    if self.success is not None:
11955 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11956 
      self.success.write(oprot)
11957 
      oprot.writeFieldEnd()
11958 
    oprot.writeFieldStop()
11959 
    oprot.writeStructEnd()
11960 
 
11961 
  def validate(self):
11962 
    return
11963 
 
11964 
 
11965 
  def __repr__(self):
11966 
    L = ['%s=%r' % (key, value)
11967 
      for key, value in self.__dict__.iteritems()]
11968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11969 
 
11970 
  def __eq__(self, other):
11971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11972 
 
11973 
  def __ne__(self, other):
11974 
    return not (self == other)
11975 
 
11976 
class getAllAmazonInventory_args:
11977 
 
11978 
  thrift_spec = (
11979 
  )
11980 
 
11981 
  def read(self, iprot):
11982 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11983 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11984 
      return
11985 
    iprot.readStructBegin()
11986 
    while True:
11987 
      (fname, ftype, fid) = iprot.readFieldBegin()
11988 
      if ftype == TType.STOP:
11989 
        break
11990 
      else:
11991 
        iprot.skip(ftype)
11992 
      iprot.readFieldEnd()
11993 
    iprot.readStructEnd()
11994 
 
11995 
  def write(self, oprot):
11996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11998 
      return
11999 
    oprot.writeStructBegin('getAllAmazonInventory_args')
12000 
    oprot.writeFieldStop()
12001 
    oprot.writeStructEnd()
12002 
 
12003 
  def validate(self):
12004 
    return
12005 
 
12006 
 
12007 
  def __repr__(self):
12008 
    L = ['%s=%r' % (key, value)
12009 
      for key, value in self.__dict__.iteritems()]
12010 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12011 
 
12012 
  def __eq__(self, other):
12013 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12014 
 
12015 
  def __ne__(self, other):
12016 
    return not (self == other)
12017 
 
12018 
class getAllAmazonInventory_result:
12019 
  """
12020 
  Attributes:
12021 
   - success
12022 
  """
12023 
 
12024 
  thrift_spec = (
12025 
    (0, TType.LIST, 'success', (TType.STRUCT,(AmazonInventorySnapshot, AmazonInventorySnapshot.thrift_spec)), None, ), # 0
12026 
  )
12027 
 
12028 
  def __init__(self, success=None,):
12029 
    self.success = success
12030 
 
12031 
  def read(self, iprot):
12032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12034 
      return
12035 
    iprot.readStructBegin()
12036 
    while True:
12037 
      (fname, ftype, fid) = iprot.readFieldBegin()
12038 
      if ftype == TType.STOP:
12039 
        break
12040 
      if fid == 0:
12041 
        if ftype == TType.LIST:
12042 
          self.success = []
10126 amar.kumar 12043 
          (_etype240, _size237) = iprot.readListBegin()
12044 
          for _i241 in xrange(_size237):
12045 
            _elem242 = AmazonInventorySnapshot()
12046 
            _elem242.read(iprot)
12047 
            self.success.append(_elem242)
7281 kshitij.so 12048 
          iprot.readListEnd()
12049 
        else:
12050 
          iprot.skip(ftype)
12051 
      else:
12052 
        iprot.skip(ftype)
12053 
      iprot.readFieldEnd()
12054 
    iprot.readStructEnd()
12055 
 
12056 
  def write(self, oprot):
12057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12059 
      return
12060 
    oprot.writeStructBegin('getAllAmazonInventory_result')
12061 
    if self.success is not None:
12062 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12063 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
10126 amar.kumar 12064 
      for iter243 in self.success:
12065 
        iter243.write(oprot)
7281 kshitij.so 12066 
      oprot.writeListEnd()
12067 
      oprot.writeFieldEnd()
12068 
    oprot.writeFieldStop()
12069 
    oprot.writeStructEnd()
12070 
 
12071 
  def validate(self):
12072 
    return
12073 
 
12074 
 
12075 
  def __repr__(self):
12076 
    L = ['%s=%r' % (key, value)
12077 
      for key, value in self.__dict__.iteritems()]
12078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12079 
 
12080 
  def __eq__(self, other):
12081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12082 
 
12083 
  def __ne__(self, other):
12084 
    return not (self == other)
12085 
 
12086 
class addOrUpdateAmazonInventoryForItem_args:
12087 
  """
12088 
  Attributes:
12089 
   - amazonInventorySnapshot
10450 vikram.rag 12090 
   - time
7281 kshitij.so 12091 
  """
12092 
 
12093 
  thrift_spec = (
12094 
    None, # 0
12095 
    (1, TType.STRUCT, 'amazonInventorySnapshot', (AmazonInventorySnapshot, AmazonInventorySnapshot.thrift_spec), None, ), # 1
10450 vikram.rag 12096 
    (2, TType.I64, 'time', None, None, ), # 2
7281 kshitij.so 12097 
  )
12098 
 
10450 vikram.rag 12099 
  def __init__(self, amazonInventorySnapshot=None, time=None,):
7281 kshitij.so 12100 
    self.amazonInventorySnapshot = amazonInventorySnapshot
10450 vikram.rag 12101 
    self.time = time
7281 kshitij.so 12102 
 
12103 
  def read(self, iprot):
12104 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12105 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12106 
      return
12107 
    iprot.readStructBegin()
12108 
    while True:
12109 
      (fname, ftype, fid) = iprot.readFieldBegin()
12110 
      if ftype == TType.STOP:
12111 
        break
12112 
      if fid == 1:
12113 
        if ftype == TType.STRUCT:
12114 
          self.amazonInventorySnapshot = AmazonInventorySnapshot()
12115 
          self.amazonInventorySnapshot.read(iprot)
12116 
        else:
12117 
          iprot.skip(ftype)
10450 vikram.rag 12118 
      elif fid == 2:
12119 
        if ftype == TType.I64:
12120 
          self.time = iprot.readI64();
12121 
        else:
12122 
          iprot.skip(ftype)
7281 kshitij.so 12123 
      else:
12124 
        iprot.skip(ftype)
12125 
      iprot.readFieldEnd()
12126 
    iprot.readStructEnd()
12127 
 
12128 
  def write(self, oprot):
12129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12131 
      return
12132 
    oprot.writeStructBegin('addOrUpdateAmazonInventoryForItem_args')
12133 
    if self.amazonInventorySnapshot is not None:
12134 
      oprot.writeFieldBegin('amazonInventorySnapshot', TType.STRUCT, 1)
12135 
      self.amazonInventorySnapshot.write(oprot)
12136 
      oprot.writeFieldEnd()
10450 vikram.rag 12137 
    if self.time is not None:
12138 
      oprot.writeFieldBegin('time', TType.I64, 2)
12139 
      oprot.writeI64(self.time)
12140 
      oprot.writeFieldEnd()
7281 kshitij.so 12141 
    oprot.writeFieldStop()
12142 
    oprot.writeStructEnd()
12143 
 
12144 
  def validate(self):
12145 
    return
12146 
 
12147 
 
12148 
  def __repr__(self):
12149 
    L = ['%s=%r' % (key, value)
12150 
      for key, value in self.__dict__.iteritems()]
12151 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12152 
 
12153 
  def __eq__(self, other):
12154 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12155 
 
12156 
  def __ne__(self, other):
12157 
    return not (self == other)
12158 
 
12159 
class addOrUpdateAmazonInventoryForItem_result:
12160 
 
12161 
  thrift_spec = (
12162 
  )
12163 
 
12164 
  def read(self, iprot):
12165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12167 
      return
12168 
    iprot.readStructBegin()
12169 
    while True:
12170 
      (fname, ftype, fid) = iprot.readFieldBegin()
12171 
      if ftype == TType.STOP:
12172 
        break
12173 
      else:
12174 
        iprot.skip(ftype)
12175 
      iprot.readFieldEnd()
12176 
    iprot.readStructEnd()
12177 
 
12178 
  def write(self, oprot):
12179 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12180 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12181 
      return
12182 
    oprot.writeStructBegin('addOrUpdateAmazonInventoryForItem_result')
12183 
    oprot.writeFieldStop()
12184 
    oprot.writeStructEnd()
12185 
 
12186 
  def validate(self):
12187 
    return
12188 
 
12189 
 
12190 
  def __repr__(self):
12191 
    L = ['%s=%r' % (key, value)
12192 
      for key, value in self.__dict__.iteritems()]
12193 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12194 
 
12195 
  def __eq__(self, other):
12196 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12197 
 
12198 
  def __ne__(self, other):
12199 
    return not (self == other)
7972 amar.kumar 12200 
 
12201 
class getLastNdaySaleForItem_args:
12202 
  """
12203 
  Attributes:
12204 
   - itemId
12205 
   - numberOfDays
12206 
  """
12207 
 
12208 
  thrift_spec = (
12209 
    None, # 0
12210 
    (1, TType.I64, 'itemId', None, None, ), # 1
12211 
    (2, TType.I64, 'numberOfDays', None, None, ), # 2
12212 
  )
12213 
 
12214 
  def __init__(self, itemId=None, numberOfDays=None,):
12215 
    self.itemId = itemId
12216 
    self.numberOfDays = numberOfDays
12217 
 
12218 
  def read(self, iprot):
12219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12221 
      return
12222 
    iprot.readStructBegin()
12223 
    while True:
12224 
      (fname, ftype, fid) = iprot.readFieldBegin()
12225 
      if ftype == TType.STOP:
12226 
        break
12227 
      if fid == 1:
12228 
        if ftype == TType.I64:
12229 
          self.itemId = iprot.readI64();
12230 
        else:
12231 
          iprot.skip(ftype)
12232 
      elif fid == 2:
12233 
        if ftype == TType.I64:
12234 
          self.numberOfDays = iprot.readI64();
12235 
        else:
12236 
          iprot.skip(ftype)
12237 
      else:
12238 
        iprot.skip(ftype)
12239 
      iprot.readFieldEnd()
12240 
    iprot.readStructEnd()
12241 
 
12242 
  def write(self, oprot):
12243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12245 
      return
12246 
    oprot.writeStructBegin('getLastNdaySaleForItem_args')
12247 
    if self.itemId is not None:
12248 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12249 
      oprot.writeI64(self.itemId)
12250 
      oprot.writeFieldEnd()
12251 
    if self.numberOfDays is not None:
12252 
      oprot.writeFieldBegin('numberOfDays', TType.I64, 2)
12253 
      oprot.writeI64(self.numberOfDays)
12254 
      oprot.writeFieldEnd()
12255 
    oprot.writeFieldStop()
12256 
    oprot.writeStructEnd()
12257 
 
12258 
  def validate(self):
12259 
    return
12260 
 
12261 
 
12262 
  def __repr__(self):
12263 
    L = ['%s=%r' % (key, value)
12264 
      for key, value in self.__dict__.iteritems()]
12265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12266 
 
12267 
  def __eq__(self, other):
12268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12269 
 
12270 
  def __ne__(self, other):
12271 
    return not (self == other)
12272 
 
12273 
class getLastNdaySaleForItem_result:
12274 
  """
12275 
  Attributes:
12276 
   - success
12277 
  """
12278 
 
12279 
  thrift_spec = (
12280 
    (0, TType.STRING, 'success', None, None, ), # 0
12281 
  )
12282 
 
12283 
  def __init__(self, success=None,):
12284 
    self.success = success
12285 
 
12286 
  def read(self, iprot):
12287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12289 
      return
12290 
    iprot.readStructBegin()
12291 
    while True:
12292 
      (fname, ftype, fid) = iprot.readFieldBegin()
12293 
      if ftype == TType.STOP:
12294 
        break
12295 
      if fid == 0:
12296 
        if ftype == TType.STRING:
12297 
          self.success = iprot.readString();
12298 
        else:
12299 
          iprot.skip(ftype)
12300 
      else:
12301 
        iprot.skip(ftype)
12302 
      iprot.readFieldEnd()
12303 
    iprot.readStructEnd()
12304 
 
12305 
  def write(self, oprot):
12306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12308 
      return
12309 
    oprot.writeStructBegin('getLastNdaySaleForItem_result')
12310 
    if self.success is not None:
12311 
      oprot.writeFieldBegin('success', TType.STRING, 0)
12312 
      oprot.writeString(self.success)
12313 
      oprot.writeFieldEnd()
12314 
    oprot.writeFieldStop()
12315 
    oprot.writeStructEnd()
12316 
 
12317 
  def validate(self):
12318 
    return
12319 
 
12320 
 
12321 
  def __repr__(self):
12322 
    L = ['%s=%r' % (key, value)
12323 
      for key, value in self.__dict__.iteritems()]
12324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12325 
 
12326 
  def __eq__(self, other):
12327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12328 
 
12329 
  def __ne__(self, other):
12330 
    return not (self == other)
8182 amar.kumar 12331 
 
8282 kshitij.so 12332 
class addOrUpdateAmazonFbaInventory_args:
12333 
  """
12334 
  Attributes:
12335 
   - amazonfbainventorysnapshot
12336 
  """
12337 
 
12338 
  thrift_spec = (
12339 
    None, # 0
12340 
    (1, TType.STRUCT, 'amazonfbainventorysnapshot', (AmazonFbaInventorySnapshot, AmazonFbaInventorySnapshot.thrift_spec), None, ), # 1
12341 
  )
12342 
 
12343 
  def __init__(self, amazonfbainventorysnapshot=None,):
12344 
    self.amazonfbainventorysnapshot = amazonfbainventorysnapshot
12345 
 
12346 
  def read(self, iprot):
12347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12349 
      return
12350 
    iprot.readStructBegin()
12351 
    while True:
12352 
      (fname, ftype, fid) = iprot.readFieldBegin()
12353 
      if ftype == TType.STOP:
12354 
        break
12355 
      if fid == 1:
12356 
        if ftype == TType.STRUCT:
12357 
          self.amazonfbainventorysnapshot = AmazonFbaInventorySnapshot()
12358 
          self.amazonfbainventorysnapshot.read(iprot)
12359 
        else:
12360 
          iprot.skip(ftype)
12361 
      else:
12362 
        iprot.skip(ftype)
12363 
      iprot.readFieldEnd()
12364 
    iprot.readStructEnd()
12365 
 
12366 
  def write(self, oprot):
12367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12369 
      return
12370 
    oprot.writeStructBegin('addOrUpdateAmazonFbaInventory_args')
12371 
    if self.amazonfbainventorysnapshot is not None:
12372 
      oprot.writeFieldBegin('amazonfbainventorysnapshot', TType.STRUCT, 1)
12373 
      self.amazonfbainventorysnapshot.write(oprot)
12374 
      oprot.writeFieldEnd()
12375 
    oprot.writeFieldStop()
12376 
    oprot.writeStructEnd()
12377 
 
12378 
  def validate(self):
12379 
    return
12380 
 
12381 
 
12382 
  def __repr__(self):
12383 
    L = ['%s=%r' % (key, value)
12384 
      for key, value in self.__dict__.iteritems()]
12385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12386 
 
12387 
  def __eq__(self, other):
12388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12389 
 
12390 
  def __ne__(self, other):
12391 
    return not (self == other)
12392 
 
12393 
class addOrUpdateAmazonFbaInventory_result:
12394 
 
12395 
  thrift_spec = (
12396 
  )
12397 
 
12398 
  def read(self, iprot):
12399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12401 
      return
12402 
    iprot.readStructBegin()
12403 
    while True:
12404 
      (fname, ftype, fid) = iprot.readFieldBegin()
12405 
      if ftype == TType.STOP:
12406 
        break
12407 
      else:
12408 
        iprot.skip(ftype)
12409 
      iprot.readFieldEnd()
12410 
    iprot.readStructEnd()
12411 
 
12412 
  def write(self, oprot):
12413 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12414 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12415 
      return
12416 
    oprot.writeStructBegin('addOrUpdateAmazonFbaInventory_result')
12417 
    oprot.writeFieldStop()
12418 
    oprot.writeStructEnd()
12419 
 
12420 
  def validate(self):
12421 
    return
12422 
 
12423 
 
12424 
  def __repr__(self):
12425 
    L = ['%s=%r' % (key, value)
12426 
      for key, value in self.__dict__.iteritems()]
12427 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12428 
 
12429 
  def __eq__(self, other):
12430 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12431 
 
12432 
  def __ne__(self, other):
12433 
    return not (self == other)
12434 
 
8182 amar.kumar 12435 
class addUpdateHoldInventory_args:
12436 
  """
12437 
  Attributes:
12438 
   - itemId
12439 
   - warehouseId
12440 
   - holdQuantity
12441 
   - source
12442 
  """
12443 
 
12444 
  thrift_spec = (
12445 
    None, # 0
12446 
    (1, TType.I64, 'itemId', None, None, ), # 1
12447 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12448 
    (3, TType.I64, 'holdQuantity', None, None, ), # 3
12449 
    (4, TType.I64, 'source', None, None, ), # 4
12450 
  )
12451 
 
12452 
  def __init__(self, itemId=None, warehouseId=None, holdQuantity=None, source=None,):
12453 
    self.itemId = itemId
12454 
    self.warehouseId = warehouseId
12455 
    self.holdQuantity = holdQuantity
12456 
    self.source = source
12457 
 
12458 
  def read(self, iprot):
12459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12461 
      return
12462 
    iprot.readStructBegin()
12463 
    while True:
12464 
      (fname, ftype, fid) = iprot.readFieldBegin()
12465 
      if ftype == TType.STOP:
12466 
        break
12467 
      if fid == 1:
12468 
        if ftype == TType.I64:
12469 
          self.itemId = iprot.readI64();
12470 
        else:
12471 
          iprot.skip(ftype)
12472 
      elif fid == 2:
12473 
        if ftype == TType.I64:
12474 
          self.warehouseId = iprot.readI64();
12475 
        else:
12476 
          iprot.skip(ftype)
12477 
      elif fid == 3:
12478 
        if ftype == TType.I64:
12479 
          self.holdQuantity = iprot.readI64();
12480 
        else:
12481 
          iprot.skip(ftype)
12482 
      elif fid == 4:
12483 
        if ftype == TType.I64:
12484 
          self.source = iprot.readI64();
12485 
        else:
12486 
          iprot.skip(ftype)
12487 
      else:
12488 
        iprot.skip(ftype)
12489 
      iprot.readFieldEnd()
12490 
    iprot.readStructEnd()
12491 
 
12492 
  def write(self, oprot):
12493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12495 
      return
12496 
    oprot.writeStructBegin('addUpdateHoldInventory_args')
12497 
    if self.itemId is not None:
12498 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12499 
      oprot.writeI64(self.itemId)
12500 
      oprot.writeFieldEnd()
12501 
    if self.warehouseId is not None:
12502 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12503 
      oprot.writeI64(self.warehouseId)
12504 
      oprot.writeFieldEnd()
12505 
    if self.holdQuantity is not None:
12506 
      oprot.writeFieldBegin('holdQuantity', TType.I64, 3)
12507 
      oprot.writeI64(self.holdQuantity)
12508 
      oprot.writeFieldEnd()
12509 
    if self.source is not None:
12510 
      oprot.writeFieldBegin('source', TType.I64, 4)
12511 
      oprot.writeI64(self.source)
12512 
      oprot.writeFieldEnd()
12513 
    oprot.writeFieldStop()
12514 
    oprot.writeStructEnd()
12515 
 
12516 
  def validate(self):
12517 
    return
12518 
 
12519 
 
12520 
  def __repr__(self):
12521 
    L = ['%s=%r' % (key, value)
12522 
      for key, value in self.__dict__.iteritems()]
12523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12524 
 
12525 
  def __eq__(self, other):
12526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12527 
 
12528 
  def __ne__(self, other):
12529 
    return not (self == other)
12530 
 
12531 
class addUpdateHoldInventory_result:
9762 amar.kumar 12532 
  """
12533 
  Attributes:
12534 
   - cex
12535 
  """
8182 amar.kumar 12536 
 
12537 
  thrift_spec = (
9762 amar.kumar 12538 
    None, # 0
12539 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
8182 amar.kumar 12540 
  )
12541 
 
9762 amar.kumar 12542 
  def __init__(self, cex=None,):
12543 
    self.cex = cex
12544 
 
8182 amar.kumar 12545 
  def read(self, iprot):
12546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12548 
      return
12549 
    iprot.readStructBegin()
12550 
    while True:
12551 
      (fname, ftype, fid) = iprot.readFieldBegin()
12552 
      if ftype == TType.STOP:
12553 
        break
9762 amar.kumar 12554 
      if fid == 1:
12555 
        if ftype == TType.STRUCT:
12556 
          self.cex = InventoryServiceException()
12557 
          self.cex.read(iprot)
12558 
        else:
12559 
          iprot.skip(ftype)
8182 amar.kumar 12560 
      else:
12561 
        iprot.skip(ftype)
12562 
      iprot.readFieldEnd()
12563 
    iprot.readStructEnd()
12564 
 
12565 
  def write(self, oprot):
12566 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12567 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12568 
      return
12569 
    oprot.writeStructBegin('addUpdateHoldInventory_result')
9762 amar.kumar 12570 
    if self.cex is not None:
12571 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12572 
      self.cex.write(oprot)
12573 
      oprot.writeFieldEnd()
8182 amar.kumar 12574 
    oprot.writeFieldStop()
12575 
    oprot.writeStructEnd()
12576 
 
12577 
  def validate(self):
12578 
    return
12579 
 
12580 
 
12581 
  def __repr__(self):
12582 
    L = ['%s=%r' % (key, value)
12583 
      for key, value in self.__dict__.iteritems()]
12584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12585 
 
12586 
  def __eq__(self, other):
12587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12588 
 
12589 
  def __ne__(self, other):
12590 
    return not (self == other)
8282 kshitij.so 12591 
 
12592 
class getAmazonFbaItemInventory_args:
12593 
  """
12594 
  Attributes:
12595 
   - itemId
12596 
  """
12597 
 
12598 
  thrift_spec = (
12599 
    None, # 0
12600 
    (1, TType.I64, 'itemId', None, None, ), # 1
12601 
  )
12602 
 
12603 
  def __init__(self, itemId=None,):
12604 
    self.itemId = itemId
12605 
 
12606 
  def read(self, iprot):
12607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12609 
      return
12610 
    iprot.readStructBegin()
12611 
    while True:
12612 
      (fname, ftype, fid) = iprot.readFieldBegin()
12613 
      if ftype == TType.STOP:
12614 
        break
12615 
      if fid == 1:
12616 
        if ftype == TType.I64:
12617 
          self.itemId = iprot.readI64();
12618 
        else:
12619 
          iprot.skip(ftype)
12620 
      else:
12621 
        iprot.skip(ftype)
12622 
      iprot.readFieldEnd()
12623 
    iprot.readStructEnd()
12624 
 
12625 
  def write(self, oprot):
12626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12628 
      return
12629 
    oprot.writeStructBegin('getAmazonFbaItemInventory_args')
12630 
    if self.itemId is not None:
12631 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12632 
      oprot.writeI64(self.itemId)
12633 
      oprot.writeFieldEnd()
12634 
    oprot.writeFieldStop()
12635 
    oprot.writeStructEnd()
12636 
 
12637 
  def validate(self):
12638 
    return
12639 
 
12640 
 
12641 
  def __repr__(self):
12642 
    L = ['%s=%r' % (key, value)
12643 
      for key, value in self.__dict__.iteritems()]
12644 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12645 
 
12646 
  def __eq__(self, other):
12647 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12648 
 
12649 
  def __ne__(self, other):
12650 
    return not (self == other)
12651 
 
12652 
class getAmazonFbaItemInventory_result:
12653 
  """
12654 
  Attributes:
12655 
   - success
12656 
  """
12657 
 
12658 
  thrift_spec = (
11173 vikram.rag 12659 
    (0, TType.LIST, 'success', (TType.STRUCT,(AmazonFbaInventorySnapshot, AmazonFbaInventorySnapshot.thrift_spec)), None, ), # 0
8282 kshitij.so 12660 
  )
12661 
 
12662 
  def __init__(self, success=None,):
12663 
    self.success = success
12664 
 
12665 
  def read(self, iprot):
12666 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12667 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12668 
      return
12669 
    iprot.readStructBegin()
12670 
    while True:
12671 
      (fname, ftype, fid) = iprot.readFieldBegin()
12672 
      if ftype == TType.STOP:
12673 
        break
12674 
      if fid == 0:
11173 vikram.rag 12675 
        if ftype == TType.LIST:
12676 
          self.success = []
12677 
          (_etype247, _size244) = iprot.readListBegin()
12678 
          for _i248 in xrange(_size244):
12679 
            _elem249 = AmazonFbaInventorySnapshot()
12680 
            _elem249.read(iprot)
12681 
            self.success.append(_elem249)
12682 
          iprot.readListEnd()
8282 kshitij.so 12683 
        else:
12684 
          iprot.skip(ftype)
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
12694 
    oprot.writeStructBegin('getAmazonFbaItemInventory_result')
12695 
    if self.success is not None:
11173 vikram.rag 12696 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12697 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
12698 
      for iter250 in self.success:
12699 
        iter250.write(oprot)
12700 
      oprot.writeListEnd()
8282 kshitij.so 12701 
      oprot.writeFieldEnd()
12702 
    oprot.writeFieldStop()
12703 
    oprot.writeStructEnd()
12704 
 
12705 
  def validate(self):
12706 
    return
12707 
 
12708 
 
12709 
  def __repr__(self):
12710 
    L = ['%s=%r' % (key, value)
12711 
      for key, value in self.__dict__.iteritems()]
12712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12713 
 
12714 
  def __eq__(self, other):
12715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12716 
 
12717 
  def __ne__(self, other):
12718 
    return not (self == other)
12719 
 
8363 vikram.rag 12720 
class getAllAmazonFbaItemInventory_args:
8282 kshitij.so 12721 
 
12722 
  thrift_spec = (
12723 
  )
12724 
 
12725 
  def read(self, iprot):
12726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12728 
      return
12729 
    iprot.readStructBegin()
12730 
    while True:
12731 
      (fname, ftype, fid) = iprot.readFieldBegin()
12732 
      if ftype == TType.STOP:
12733 
        break
12734 
      else:
12735 
        iprot.skip(ftype)
12736 
      iprot.readFieldEnd()
12737 
    iprot.readStructEnd()
12738 
 
12739 
  def write(self, oprot):
12740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12742 
      return
8363 vikram.rag 12743 
    oprot.writeStructBegin('getAllAmazonFbaItemInventory_args')
8282 kshitij.so 12744 
    oprot.writeFieldStop()
12745 
    oprot.writeStructEnd()
12746 
 
12747 
  def validate(self):
12748 
    return
12749 
 
12750 
 
12751 
  def __repr__(self):
12752 
    L = ['%s=%r' % (key, value)
12753 
      for key, value in self.__dict__.iteritems()]
12754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12755 
 
12756 
  def __eq__(self, other):
12757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12758 
 
12759 
  def __ne__(self, other):
12760 
    return not (self == other)
12761 
 
8363 vikram.rag 12762 
class getAllAmazonFbaItemInventory_result:
8282 kshitij.so 12763 
  """
12764 
  Attributes:
12765 
   - success
12766 
  """
12767 
 
12768 
  thrift_spec = (
12769 
    (0, TType.LIST, 'success', (TType.STRUCT,(AmazonFbaInventorySnapshot, AmazonFbaInventorySnapshot.thrift_spec)), None, ), # 0
12770 
  )
12771 
 
12772 
  def __init__(self, success=None,):
12773 
    self.success = success
12774 
 
12775 
  def read(self, iprot):
12776 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12777 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12778 
      return
12779 
    iprot.readStructBegin()
12780 
    while True:
12781 
      (fname, ftype, fid) = iprot.readFieldBegin()
12782 
      if ftype == TType.STOP:
12783 
        break
12784 
      if fid == 0:
12785 
        if ftype == TType.LIST:
12786 
          self.success = []
11173 vikram.rag 12787 
          (_etype254, _size251) = iprot.readListBegin()
12788 
          for _i255 in xrange(_size251):
12789 
            _elem256 = AmazonFbaInventorySnapshot()
12790 
            _elem256.read(iprot)
12791 
            self.success.append(_elem256)
8282 kshitij.so 12792 
          iprot.readListEnd()
12793 
        else:
12794 
          iprot.skip(ftype)
12795 
      else:
12796 
        iprot.skip(ftype)
12797 
      iprot.readFieldEnd()
12798 
    iprot.readStructEnd()
12799 
 
12800 
  def write(self, oprot):
12801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12803 
      return
8363 vikram.rag 12804 
    oprot.writeStructBegin('getAllAmazonFbaItemInventory_result')
8282 kshitij.so 12805 
    if self.success is not None:
12806 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12807 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11173 vikram.rag 12808 
      for iter257 in self.success:
12809 
        iter257.write(oprot)
8282 kshitij.so 12810 
      oprot.writeListEnd()
12811 
      oprot.writeFieldEnd()
12812 
    oprot.writeFieldStop()
12813 
    oprot.writeStructEnd()
12814 
 
12815 
  def validate(self):
12816 
    return
12817 
 
12818 
 
12819 
  def __repr__(self):
12820 
    L = ['%s=%r' % (key, value)
12821 
      for key, value in self.__dict__.iteritems()]
12822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12823 
 
12824 
  def __eq__(self, other):
12825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12826 
 
12827 
  def __ne__(self, other):
12828 
    return not (self == other)
8363 vikram.rag 12829 
 
12830 
class getOursGoodWarehouseIdsForLocation_args:
12831 
  """
12832 
  Attributes:
12833 
   - state_id
12834 
  """
12835 
 
12836 
  thrift_spec = (
12837 
    None, # 0
12838 
    (1, TType.I64, 'state_id', None, None, ), # 1
12839 
  )
12840 
 
12841 
  def __init__(self, state_id=None,):
12842 
    self.state_id = state_id
12843 
 
12844 
  def read(self, iprot):
12845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12847 
      return
12848 
    iprot.readStructBegin()
12849 
    while True:
12850 
      (fname, ftype, fid) = iprot.readFieldBegin()
12851 
      if ftype == TType.STOP:
12852 
        break
12853 
      if fid == 1:
12854 
        if ftype == TType.I64:
12855 
          self.state_id = iprot.readI64();
12856 
        else:
12857 
          iprot.skip(ftype)
12858 
      else:
12859 
        iprot.skip(ftype)
12860 
      iprot.readFieldEnd()
12861 
    iprot.readStructEnd()
12862 
 
12863 
  def write(self, oprot):
12864 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12865 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12866 
      return
12867 
    oprot.writeStructBegin('getOursGoodWarehouseIdsForLocation_args')
12868 
    if self.state_id is not None:
12869 
      oprot.writeFieldBegin('state_id', TType.I64, 1)
12870 
      oprot.writeI64(self.state_id)
12871 
      oprot.writeFieldEnd()
12872 
    oprot.writeFieldStop()
12873 
    oprot.writeStructEnd()
12874 
 
12875 
  def validate(self):
12876 
    return
12877 
 
12878 
 
12879 
  def __repr__(self):
12880 
    L = ['%s=%r' % (key, value)
12881 
      for key, value in self.__dict__.iteritems()]
12882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12883 
 
12884 
  def __eq__(self, other):
12885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12886 
 
12887 
  def __ne__(self, other):
12888 
    return not (self == other)
12889 
 
12890 
class getOursGoodWarehouseIdsForLocation_result:
12891 
  """
12892 
  Attributes:
12893 
   - success
12894 
  """
12895 
 
12896 
  thrift_spec = (
12897 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12898 
  )
12899 
 
12900 
  def __init__(self, success=None,):
12901 
    self.success = success
12902 
 
12903 
  def read(self, iprot):
12904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12906 
      return
12907 
    iprot.readStructBegin()
12908 
    while True:
12909 
      (fname, ftype, fid) = iprot.readFieldBegin()
12910 
      if ftype == TType.STOP:
12911 
        break
12912 
      if fid == 0:
12913 
        if ftype == TType.LIST:
12914 
          self.success = []
11173 vikram.rag 12915 
          (_etype261, _size258) = iprot.readListBegin()
12916 
          for _i262 in xrange(_size258):
12917 
            _elem263 = iprot.readI64();
12918 
            self.success.append(_elem263)
8363 vikram.rag 12919 
          iprot.readListEnd()
12920 
        else:
12921 
          iprot.skip(ftype)
12922 
      else:
12923 
        iprot.skip(ftype)
12924 
      iprot.readFieldEnd()
12925 
    iprot.readStructEnd()
12926 
 
12927 
  def write(self, oprot):
12928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12930 
      return
12931 
    oprot.writeStructBegin('getOursGoodWarehouseIdsForLocation_result')
12932 
    if self.success is not None:
12933 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12934 
      oprot.writeListBegin(TType.I64, len(self.success))
11173 vikram.rag 12935 
      for iter264 in self.success:
12936 
        oprot.writeI64(iter264)
8363 vikram.rag 12937 
      oprot.writeListEnd()
12938 
      oprot.writeFieldEnd()
12939 
    oprot.writeFieldStop()
12940 
    oprot.writeStructEnd()
12941 
 
12942 
  def validate(self):
12943 
    return
12944 
 
12945 
 
12946 
  def __repr__(self):
12947 
    L = ['%s=%r' % (key, value)
12948 
      for key, value in self.__dict__.iteritems()]
12949 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12950 
 
12951 
  def __eq__(self, other):
12952 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12953 
 
12954 
  def __ne__(self, other):
12955 
    return not (self == other)
8955 vikram.rag 12956 
 
12957 
class getHoldInventoryDetailForItemForWarehouseIdExceptSource_args:
12958 
  """
12959 
  Attributes:
12960 
   - id
12961 
   - warehouse_id
12962 
   - source
12963 
  """
12964 
 
12965 
  thrift_spec = (
12966 
    None, # 0
12967 
    (1, TType.I64, 'id', None, None, ), # 1
12968 
    (2, TType.I64, 'warehouse_id', None, None, ), # 2
12969 
    (3, TType.I64, 'source', None, None, ), # 3
12970 
  )
12971 
 
12972 
  def __init__(self, id=None, warehouse_id=None, source=None,):
12973 
    self.id = id
12974 
    self.warehouse_id = warehouse_id
12975 
    self.source = source
12976 
 
12977 
  def read(self, iprot):
12978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12980 
      return
12981 
    iprot.readStructBegin()
12982 
    while True:
12983 
      (fname, ftype, fid) = iprot.readFieldBegin()
12984 
      if ftype == TType.STOP:
12985 
        break
12986 
      if fid == 1:
12987 
        if ftype == TType.I64:
12988 
          self.id = iprot.readI64();
12989 
        else:
12990 
          iprot.skip(ftype)
12991 
      elif fid == 2:
12992 
        if ftype == TType.I64:
12993 
          self.warehouse_id = iprot.readI64();
12994 
        else:
12995 
          iprot.skip(ftype)
12996 
      elif fid == 3:
12997 
        if ftype == TType.I64:
12998 
          self.source = iprot.readI64();
12999 
        else:
13000 
          iprot.skip(ftype)
13001 
      else:
13002 
        iprot.skip(ftype)
13003 
      iprot.readFieldEnd()
13004 
    iprot.readStructEnd()
13005 
 
13006 
  def write(self, oprot):
13007 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13008 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13009 
      return
13010 
    oprot.writeStructBegin('getHoldInventoryDetailForItemForWarehouseIdExceptSource_args')
13011 
    if self.id is not None:
13012 
      oprot.writeFieldBegin('id', TType.I64, 1)
13013 
      oprot.writeI64(self.id)
13014 
      oprot.writeFieldEnd()
13015 
    if self.warehouse_id is not None:
13016 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 2)
13017 
      oprot.writeI64(self.warehouse_id)
13018 
      oprot.writeFieldEnd()
13019 
    if self.source is not None:
13020 
      oprot.writeFieldBegin('source', TType.I64, 3)
13021 
      oprot.writeI64(self.source)
13022 
      oprot.writeFieldEnd()
13023 
    oprot.writeFieldStop()
13024 
    oprot.writeStructEnd()
13025 
 
13026 
  def validate(self):
13027 
    return
13028 
 
13029 
 
13030 
  def __repr__(self):
13031 
    L = ['%s=%r' % (key, value)
13032 
      for key, value in self.__dict__.iteritems()]
13033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13034 
 
13035 
  def __eq__(self, other):
13036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13037 
 
13038 
  def __ne__(self, other):
13039 
    return not (self == other)
13040 
 
13041 
class getHoldInventoryDetailForItemForWarehouseIdExceptSource_result:
13042 
  """
13043 
  Attributes:
13044 
   - success
13045 
  """
13046 
 
13047 
  thrift_spec = (
13048 
    (0, TType.I64, 'success', None, None, ), # 0
13049 
  )
13050 
 
13051 
  def __init__(self, success=None,):
13052 
    self.success = success
13053 
 
13054 
  def read(self, iprot):
13055 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13056 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13057 
      return
13058 
    iprot.readStructBegin()
13059 
    while True:
13060 
      (fname, ftype, fid) = iprot.readFieldBegin()
13061 
      if ftype == TType.STOP:
13062 
        break
13063 
      if fid == 0:
13064 
        if ftype == TType.I64:
13065 
          self.success = iprot.readI64();
13066 
        else:
13067 
          iprot.skip(ftype)
13068 
      else:
13069 
        iprot.skip(ftype)
13070 
      iprot.readFieldEnd()
13071 
    iprot.readStructEnd()
13072 
 
13073 
  def write(self, oprot):
13074 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13075 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13076 
      return
13077 
    oprot.writeStructBegin('getHoldInventoryDetailForItemForWarehouseIdExceptSource_result')
13078 
    if self.success is not None:
13079 
      oprot.writeFieldBegin('success', TType.I64, 0)
13080 
      oprot.writeI64(self.success)
13081 
      oprot.writeFieldEnd()
13082 
    oprot.writeFieldStop()
13083 
    oprot.writeStructEnd()
13084 
 
13085 
  def validate(self):
13086 
    return
13087 
 
13088 
 
13089 
  def __repr__(self):
13090 
    L = ['%s=%r' % (key, value)
13091 
      for key, value in self.__dict__.iteritems()]
13092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13093 
 
13094 
  def __eq__(self, other):
13095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13096 
 
13097 
  def __ne__(self, other):
13098 
    return not (self == other)
9404 vikram.rag 13099 
 
13100 
class getSnapdealInventoryForItem_args:
13101 
  """
13102 
  Attributes:
13103 
   - item_id
13104 
  """
13105 
 
13106 
  thrift_spec = (
13107 
    None, # 0
13108 
    (1, TType.I64, 'item_id', None, None, ), # 1
13109 
  )
13110 
 
13111 
  def __init__(self, item_id=None,):
13112 
    self.item_id = item_id
13113 
 
13114 
  def read(self, iprot):
13115 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13116 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13117 
      return
13118 
    iprot.readStructBegin()
13119 
    while True:
13120 
      (fname, ftype, fid) = iprot.readFieldBegin()
13121 
      if ftype == TType.STOP:
13122 
        break
13123 
      if fid == 1:
13124 
        if ftype == TType.I64:
13125 
          self.item_id = iprot.readI64();
13126 
        else:
13127 
          iprot.skip(ftype)
13128 
      else:
13129 
        iprot.skip(ftype)
13130 
      iprot.readFieldEnd()
13131 
    iprot.readStructEnd()
13132 
 
13133 
  def write(self, oprot):
13134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13136 
      return
13137 
    oprot.writeStructBegin('getSnapdealInventoryForItem_args')
13138 
    if self.item_id is not None:
13139 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
13140 
      oprot.writeI64(self.item_id)
13141 
      oprot.writeFieldEnd()
13142 
    oprot.writeFieldStop()
13143 
    oprot.writeStructEnd()
13144 
 
13145 
  def validate(self):
13146 
    return
13147 
 
13148 
 
13149 
  def __repr__(self):
13150 
    L = ['%s=%r' % (key, value)
13151 
      for key, value in self.__dict__.iteritems()]
13152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13153 
 
13154 
  def __eq__(self, other):
13155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13156 
 
13157 
  def __ne__(self, other):
13158 
    return not (self == other)
13159 
 
13160 
class getSnapdealInventoryForItem_result:
13161 
  """
13162 
  Attributes:
13163 
   - success
13164 
  """
13165 
 
13166 
  thrift_spec = (
13167 
    (0, TType.STRUCT, 'success', (SnapdealInventoryItem, SnapdealInventoryItem.thrift_spec), None, ), # 0
13168 
  )
13169 
 
13170 
  def __init__(self, success=None,):
13171 
    self.success = success
13172 
 
13173 
  def read(self, iprot):
13174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13176 
      return
13177 
    iprot.readStructBegin()
13178 
    while True:
13179 
      (fname, ftype, fid) = iprot.readFieldBegin()
13180 
      if ftype == TType.STOP:
13181 
        break
13182 
      if fid == 0:
13183 
        if ftype == TType.STRUCT:
13184 
          self.success = SnapdealInventoryItem()
13185 
          self.success.read(iprot)
13186 
        else:
13187 
          iprot.skip(ftype)
13188 
      else:
13189 
        iprot.skip(ftype)
13190 
      iprot.readFieldEnd()
13191 
    iprot.readStructEnd()
13192 
 
13193 
  def write(self, oprot):
13194 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13195 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13196 
      return
13197 
    oprot.writeStructBegin('getSnapdealInventoryForItem_result')
13198 
    if self.success is not None:
13199 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13200 
      self.success.write(oprot)
13201 
      oprot.writeFieldEnd()
13202 
    oprot.writeFieldStop()
13203 
    oprot.writeStructEnd()
13204 
 
13205 
  def validate(self):
13206 
    return
13207 
 
13208 
 
13209 
  def __repr__(self):
13210 
    L = ['%s=%r' % (key, value)
13211 
      for key, value in self.__dict__.iteritems()]
13212 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13213 
 
13214 
  def __eq__(self, other):
13215 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13216 
 
13217 
  def __ne__(self, other):
13218 
    return not (self == other)
13219 
 
13220 
class addOrUpdateSnapdealInventoryForItem_args:
13221 
  """
13222 
  Attributes:
13223 
   - snapdealinventoryitem
13224 
  """
13225 
 
13226 
  thrift_spec = (
13227 
    None, # 0
13228 
    (1, TType.STRUCT, 'snapdealinventoryitem', (SnapdealInventoryItem, SnapdealInventoryItem.thrift_spec), None, ), # 1
13229 
  )
13230 
 
13231 
  def __init__(self, snapdealinventoryitem=None,):
13232 
    self.snapdealinventoryitem = snapdealinventoryitem
13233 
 
13234 
  def read(self, iprot):
13235 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13236 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13237 
      return
13238 
    iprot.readStructBegin()
13239 
    while True:
13240 
      (fname, ftype, fid) = iprot.readFieldBegin()
13241 
      if ftype == TType.STOP:
13242 
        break
13243 
      if fid == 1:
13244 
        if ftype == TType.STRUCT:
13245 
          self.snapdealinventoryitem = SnapdealInventoryItem()
13246 
          self.snapdealinventoryitem.read(iprot)
13247 
        else:
13248 
          iprot.skip(ftype)
13249 
      else:
13250 
        iprot.skip(ftype)
13251 
      iprot.readFieldEnd()
13252 
    iprot.readStructEnd()
13253 
 
13254 
  def write(self, oprot):
13255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13257 
      return
13258 
    oprot.writeStructBegin('addOrUpdateSnapdealInventoryForItem_args')
13259 
    if self.snapdealinventoryitem is not None:
13260 
      oprot.writeFieldBegin('snapdealinventoryitem', TType.STRUCT, 1)
13261 
      self.snapdealinventoryitem.write(oprot)
13262 
      oprot.writeFieldEnd()
13263 
    oprot.writeFieldStop()
13264 
    oprot.writeStructEnd()
13265 
 
13266 
  def validate(self):
13267 
    return
13268 
 
13269 
 
13270 
  def __repr__(self):
13271 
    L = ['%s=%r' % (key, value)
13272 
      for key, value in self.__dict__.iteritems()]
13273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13274 
 
13275 
  def __eq__(self, other):
13276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13277 
 
13278 
  def __ne__(self, other):
13279 
    return not (self == other)
13280 
 
13281 
class addOrUpdateSnapdealInventoryForItem_result:
13282 
 
13283 
  thrift_spec = (
13284 
  )
13285 
 
13286 
  def read(self, iprot):
13287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13289 
      return
13290 
    iprot.readStructBegin()
13291 
    while True:
13292 
      (fname, ftype, fid) = iprot.readFieldBegin()
13293 
      if ftype == TType.STOP:
13294 
        break
13295 
      else:
13296 
        iprot.skip(ftype)
13297 
      iprot.readFieldEnd()
13298 
    iprot.readStructEnd()
13299 
 
13300 
  def write(self, oprot):
13301 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13302 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13303 
      return
13304 
    oprot.writeStructBegin('addOrUpdateSnapdealInventoryForItem_result')
13305 
    oprot.writeFieldStop()
13306 
    oprot.writeStructEnd()
13307 
 
13308 
  def validate(self):
13309 
    return
13310 
 
13311 
 
13312 
  def __repr__(self):
13313 
    L = ['%s=%r' % (key, value)
13314 
      for key, value in self.__dict__.iteritems()]
13315 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13316 
 
13317 
  def __eq__(self, other):
13318 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13319 
 
13320 
  def __ne__(self, other):
13321 
    return not (self == other)
13322 
 
13323 
class getNlcForWarehouse_args:
13324 
  """
13325 
  Attributes:
13326 
   - warehouse_id
13327 
   - item_id
13328 
  """
13329 
 
13330 
  thrift_spec = (
13331 
    None, # 0
13332 
    (1, TType.I64, 'warehouse_id', None, None, ), # 1
13333 
    (2, TType.I64, 'item_id', None, None, ), # 2
13334 
  )
13335 
 
13336 
  def __init__(self, warehouse_id=None, item_id=None,):
13337 
    self.warehouse_id = warehouse_id
13338 
    self.item_id = item_id
13339 
 
13340 
  def read(self, iprot):
13341 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13342 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13343 
      return
13344 
    iprot.readStructBegin()
13345 
    while True:
13346 
      (fname, ftype, fid) = iprot.readFieldBegin()
13347 
      if ftype == TType.STOP:
13348 
        break
13349 
      if fid == 1:
13350 
        if ftype == TType.I64:
13351 
          self.warehouse_id = iprot.readI64();
13352 
        else:
13353 
          iprot.skip(ftype)
13354 
      elif fid == 2:
13355 
        if ftype == TType.I64:
13356 
          self.item_id = iprot.readI64();
13357 
        else:
13358 
          iprot.skip(ftype)
13359 
      else:
13360 
        iprot.skip(ftype)
13361 
      iprot.readFieldEnd()
13362 
    iprot.readStructEnd()
13363 
 
13364 
  def write(self, oprot):
13365 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13366 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13367 
      return
13368 
    oprot.writeStructBegin('getNlcForWarehouse_args')
13369 
    if self.warehouse_id is not None:
13370 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 1)
13371 
      oprot.writeI64(self.warehouse_id)
13372 
      oprot.writeFieldEnd()
13373 
    if self.item_id is not None:
13374 
      oprot.writeFieldBegin('item_id', TType.I64, 2)
13375 
      oprot.writeI64(self.item_id)
13376 
      oprot.writeFieldEnd()
13377 
    oprot.writeFieldStop()
13378 
    oprot.writeStructEnd()
13379 
 
13380 
  def validate(self):
13381 
    return
13382 
 
13383 
 
13384 
  def __repr__(self):
13385 
    L = ['%s=%r' % (key, value)
13386 
      for key, value in self.__dict__.iteritems()]
13387 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13388 
 
13389 
  def __eq__(self, other):
13390 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13391 
 
13392 
  def __ne__(self, other):
13393 
    return not (self == other)
13394 
 
13395 
class getNlcForWarehouse_result:
13396 
  """
13397 
  Attributes:
13398 
   - success
13399 
  """
13400 
 
13401 
  thrift_spec = (
13402 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
13403 
  )
13404 
 
13405 
  def __init__(self, success=None,):
13406 
    self.success = success
13407 
 
13408 
  def read(self, iprot):
13409 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13410 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13411 
      return
13412 
    iprot.readStructBegin()
13413 
    while True:
13414 
      (fname, ftype, fid) = iprot.readFieldBegin()
13415 
      if ftype == TType.STOP:
13416 
        break
13417 
      if fid == 0:
13418 
        if ftype == TType.DOUBLE:
13419 
          self.success = iprot.readDouble();
13420 
        else:
13421 
          iprot.skip(ftype)
13422 
      else:
13423 
        iprot.skip(ftype)
13424 
      iprot.readFieldEnd()
13425 
    iprot.readStructEnd()
13426 
 
13427 
  def write(self, oprot):
13428 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13429 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13430 
      return
13431 
    oprot.writeStructBegin('getNlcForWarehouse_result')
13432 
    if self.success is not None:
13433 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
13434 
      oprot.writeDouble(self.success)
13435 
      oprot.writeFieldEnd()
13436 
    oprot.writeFieldStop()
13437 
    oprot.writeStructEnd()
13438 
 
13439 
  def validate(self):
13440 
    return
13441 
 
13442 
 
13443 
  def __repr__(self):
13444 
    L = ['%s=%r' % (key, value)
13445 
      for key, value in self.__dict__.iteritems()]
13446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13447 
 
13448 
  def __eq__(self, other):
13449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13450 
 
13451 
  def __ne__(self, other):
13452 
    return not (self == other)
9456 vikram.rag 13453 
 
9640 amar.kumar 13454 
class getHeldInventoryMapForItem_args:
13455 
  """
13456 
  Attributes:
13457 
   - item_id
13458 
   - warehouse_id
13459 
  """
13460 
 
13461 
  thrift_spec = (
13462 
    None, # 0
13463 
    (1, TType.I64, 'item_id', None, None, ), # 1
13464 
    (2, TType.I64, 'warehouse_id', None, None, ), # 2
13465 
  )
13466 
 
13467 
  def __init__(self, item_id=None, warehouse_id=None,):
13468 
    self.item_id = item_id
13469 
    self.warehouse_id = warehouse_id
13470 
 
13471 
  def read(self, iprot):
13472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13474 
      return
13475 
    iprot.readStructBegin()
13476 
    while True:
13477 
      (fname, ftype, fid) = iprot.readFieldBegin()
13478 
      if ftype == TType.STOP:
13479 
        break
13480 
      if fid == 1:
13481 
        if ftype == TType.I64:
13482 
          self.item_id = iprot.readI64();
13483 
        else:
13484 
          iprot.skip(ftype)
13485 
      elif fid == 2:
13486 
        if ftype == TType.I64:
13487 
          self.warehouse_id = iprot.readI64();
13488 
        else:
13489 
          iprot.skip(ftype)
13490 
      else:
13491 
        iprot.skip(ftype)
13492 
      iprot.readFieldEnd()
13493 
    iprot.readStructEnd()
13494 
 
13495 
  def write(self, oprot):
13496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13498 
      return
13499 
    oprot.writeStructBegin('getHeldInventoryMapForItem_args')
13500 
    if self.item_id is not None:
13501 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
13502 
      oprot.writeI64(self.item_id)
13503 
      oprot.writeFieldEnd()
13504 
    if self.warehouse_id is not None:
13505 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 2)
13506 
      oprot.writeI64(self.warehouse_id)
13507 
      oprot.writeFieldEnd()
13508 
    oprot.writeFieldStop()
13509 
    oprot.writeStructEnd()
13510 
 
13511 
  def validate(self):
13512 
    return
13513 
 
13514 
 
13515 
  def __repr__(self):
13516 
    L = ['%s=%r' % (key, value)
13517 
      for key, value in self.__dict__.iteritems()]
13518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13519 
 
13520 
  def __eq__(self, other):
13521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13522 
 
13523 
  def __ne__(self, other):
13524 
    return not (self == other)
13525 
 
13526 
class getHeldInventoryMapForItem_result:
13527 
  """
13528 
  Attributes:
13529 
   - success
13530 
  """
13531 
 
13532 
  thrift_spec = (
13533 
    (0, TType.MAP, 'success', (TType.I32,None,TType.I64,None), None, ), # 0
13534 
  )
13535 
 
13536 
  def __init__(self, success=None,):
13537 
    self.success = success
13538 
 
13539 
  def read(self, iprot):
13540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13542 
      return
13543 
    iprot.readStructBegin()
13544 
    while True:
13545 
      (fname, ftype, fid) = iprot.readFieldBegin()
13546 
      if ftype == TType.STOP:
13547 
        break
13548 
      if fid == 0:
13549 
        if ftype == TType.MAP:
13550 
          self.success = {}
11173 vikram.rag 13551 
          (_ktype266, _vtype267, _size265 ) = iprot.readMapBegin()
13552 
          for _i269 in xrange(_size265):
13553 
            _key270 = iprot.readI32();
13554 
            _val271 = iprot.readI64();
13555 
            self.success[_key270] = _val271
9640 amar.kumar 13556 
          iprot.readMapEnd()
13557 
        else:
13558 
          iprot.skip(ftype)
13559 
      else:
13560 
        iprot.skip(ftype)
13561 
      iprot.readFieldEnd()
13562 
    iprot.readStructEnd()
13563 
 
13564 
  def write(self, oprot):
13565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13567 
      return
13568 
    oprot.writeStructBegin('getHeldInventoryMapForItem_result')
13569 
    if self.success is not None:
13570 
      oprot.writeFieldBegin('success', TType.MAP, 0)
13571 
      oprot.writeMapBegin(TType.I32, TType.I64, len(self.success))
11173 vikram.rag 13572 
      for kiter272,viter273 in self.success.items():
13573 
        oprot.writeI32(kiter272)
13574 
        oprot.writeI64(viter273)
9640 amar.kumar 13575 
      oprot.writeMapEnd()
13576 
      oprot.writeFieldEnd()
13577 
    oprot.writeFieldStop()
13578 
    oprot.writeStructEnd()
13579 
 
13580 
  def validate(self):
13581 
    return
13582 
 
13583 
 
13584 
  def __repr__(self):
13585 
    L = ['%s=%r' % (key, value)
13586 
      for key, value in self.__dict__.iteritems()]
13587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13588 
 
13589 
  def __eq__(self, other):
13590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13591 
 
13592 
  def __ne__(self, other):
13593 
    return not (self == other)
13594 
 
9495 vikram.rag 13595 
class addOrUpdateAllAmazonFbaInventory_args:
13596 
  """
13597 
  Attributes:
13598 
   - allamazonfbainventorysnapshot
13599 
  """
9456 vikram.rag 13600 
 
9495 vikram.rag 13601 
  thrift_spec = None
13602 
  def __init__(self, allamazonfbainventorysnapshot=None,):
13603 
    self.allamazonfbainventorysnapshot = allamazonfbainventorysnapshot
9456 vikram.rag 13604 
 
13605 
  def read(self, iprot):
13606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13608 
      return
13609 
    iprot.readStructBegin()
13610 
    while True:
13611 
      (fname, ftype, fid) = iprot.readFieldBegin()
13612 
      if ftype == TType.STOP:
13613 
        break
9495 vikram.rag 13614 
      if fid == -1:
13615 
        if ftype == TType.LIST:
13616 
          self.allamazonfbainventorysnapshot = []
11173 vikram.rag 13617 
          (_etype277, _size274) = iprot.readListBegin()
13618 
          for _i278 in xrange(_size274):
13619 
            _elem279 = AmazonFbaInventorySnapshot()
13620 
            _elem279.read(iprot)
13621 
            self.allamazonfbainventorysnapshot.append(_elem279)
9495 vikram.rag 13622 
          iprot.readListEnd()
13623 
        else:
13624 
          iprot.skip(ftype)
9456 vikram.rag 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_args')
13635 
    if self.allamazonfbainventorysnapshot is not None:
13636 
      oprot.writeFieldBegin('allamazonfbainventorysnapshot', TType.LIST, -1)
13637 
      oprot.writeListBegin(TType.STRUCT, len(self.allamazonfbainventorysnapshot))
11173 vikram.rag 13638 
      for iter280 in self.allamazonfbainventorysnapshot:
13639 
        iter280.write(oprot)
9495 vikram.rag 13640 
      oprot.writeListEnd()
13641 
      oprot.writeFieldEnd()
9456 vikram.rag 13642 
    oprot.writeFieldStop()
13643 
    oprot.writeStructEnd()
13644 
 
13645 
  def validate(self):
13646 
    return
13647 
 
13648 
 
13649 
  def __repr__(self):
13650 
    L = ['%s=%r' % (key, value)
13651 
      for key, value in self.__dict__.iteritems()]
13652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13653 
 
13654 
  def __eq__(self, other):
13655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13656 
 
13657 
  def __ne__(self, other):
13658 
    return not (self == other)
13659 
 
9495 vikram.rag 13660 
class addOrUpdateAllAmazonFbaInventory_result:
9456 vikram.rag 13661 
 
13662 
  thrift_spec = (
13663 
  )
13664 
 
13665 
  def read(self, iprot):
13666 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13667 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13668 
      return
13669 
    iprot.readStructBegin()
13670 
    while True:
13671 
      (fname, ftype, fid) = iprot.readFieldBegin()
13672 
      if ftype == TType.STOP:
13673 
        break
13674 
      else:
13675 
        iprot.skip(ftype)
13676 
      iprot.readFieldEnd()
13677 
    iprot.readStructEnd()
13678 
 
13679 
  def write(self, oprot):
13680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13682 
      return
9495 vikram.rag 13683 
    oprot.writeStructBegin('addOrUpdateAllAmazonFbaInventory_result')
9456 vikram.rag 13684 
    oprot.writeFieldStop()
13685 
    oprot.writeStructEnd()
13686 
 
13687 
  def validate(self):
13688 
    return
13689 
 
13690 
 
13691 
  def __repr__(self):
13692 
    L = ['%s=%r' % (key, value)
13693 
      for key, value in self.__dict__.iteritems()]
13694 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13695 
 
13696 
  def __eq__(self, other):
13697 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13698 
 
13699 
  def __ne__(self, other):
13700 
    return not (self == other)
9482 vikram.rag 13701 
 
9495 vikram.rag 13702 
class addOrUpdateAllSnapdealInventory_args:
9482 vikram.rag 13703 
  """
13704 
  Attributes:
9495 vikram.rag 13705 
   - allsnapdealinventorysnapshot
9482 vikram.rag 13706 
  """
13707 
 
13708 
  thrift_spec = None
9495 vikram.rag 13709 
  def __init__(self, allsnapdealinventorysnapshot=None,):
13710 
    self.allsnapdealinventorysnapshot = allsnapdealinventorysnapshot
9482 vikram.rag 13711 
 
13712 
  def read(self, iprot):
13713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13715 
      return
13716 
    iprot.readStructBegin()
13717 
    while True:
13718 
      (fname, ftype, fid) = iprot.readFieldBegin()
13719 
      if ftype == TType.STOP:
13720 
        break
13721 
      if fid == -1:
13722 
        if ftype == TType.LIST:
9495 vikram.rag 13723 
          self.allsnapdealinventorysnapshot = []
11173 vikram.rag 13724 
          (_etype284, _size281) = iprot.readListBegin()
13725 
          for _i285 in xrange(_size281):
13726 
            _elem286 = SnapdealInventoryItem()
13727 
            _elem286.read(iprot)
13728 
            self.allsnapdealinventorysnapshot.append(_elem286)
9482 vikram.rag 13729 
          iprot.readListEnd()
13730 
        else:
13731 
          iprot.skip(ftype)
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_args')
13742 
    if self.allsnapdealinventorysnapshot is not None:
13743 
      oprot.writeFieldBegin('allsnapdealinventorysnapshot', TType.LIST, -1)
13744 
      oprot.writeListBegin(TType.STRUCT, len(self.allsnapdealinventorysnapshot))
11173 vikram.rag 13745 
      for iter287 in self.allsnapdealinventorysnapshot:
13746 
        iter287.write(oprot)
9482 vikram.rag 13747 
      oprot.writeListEnd()
13748 
      oprot.writeFieldEnd()
13749 
    oprot.writeFieldStop()
13750 
    oprot.writeStructEnd()
13751 
 
13752 
  def validate(self):
13753 
    return
13754 
 
13755 
 
13756 
  def __repr__(self):
13757 
    L = ['%s=%r' % (key, value)
13758 
      for key, value in self.__dict__.iteritems()]
13759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13760 
 
13761 
  def __eq__(self, other):
13762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13763 
 
13764 
  def __ne__(self, other):
13765 
    return not (self == other)
13766 
 
9495 vikram.rag 13767 
class addOrUpdateAllSnapdealInventory_result:
9482 vikram.rag 13768 
 
13769 
  thrift_spec = (
13770 
  )
13771 
 
13772 
  def read(self, iprot):
13773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13775 
      return
13776 
    iprot.readStructBegin()
13777 
    while True:
13778 
      (fname, ftype, fid) = iprot.readFieldBegin()
13779 
      if ftype == TType.STOP:
13780 
        break
13781 
      else:
13782 
        iprot.skip(ftype)
13783 
      iprot.readFieldEnd()
13784 
    iprot.readStructEnd()
13785 
 
13786 
  def write(self, oprot):
13787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13789 
      return
9495 vikram.rag 13790 
    oprot.writeStructBegin('addOrUpdateAllSnapdealInventory_result')
9482 vikram.rag 13791 
    oprot.writeFieldStop()
13792 
    oprot.writeStructEnd()
13793 
 
13794 
  def validate(self):
13795 
    return
13796 
 
13797 
 
13798 
  def __repr__(self):
13799 
    L = ['%s=%r' % (key, value)
13800 
      for key, value in self.__dict__.iteritems()]
13801 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13802 
 
13803 
  def __eq__(self, other):
13804 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13805 
 
13806 
  def __ne__(self, other):
13807 
    return not (self == other)
9495 vikram.rag 13808 
 
13809 
class getSnapdealInventorySnapshot_args:
13810 
 
13811 
  thrift_spec = (
13812 
  )
13813 
 
13814 
  def read(self, iprot):
13815 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13816 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13817 
      return
13818 
    iprot.readStructBegin()
13819 
    while True:
13820 
      (fname, ftype, fid) = iprot.readFieldBegin()
13821 
      if ftype == TType.STOP:
13822 
        break
13823 
      else:
13824 
        iprot.skip(ftype)
13825 
      iprot.readFieldEnd()
13826 
    iprot.readStructEnd()
13827 
 
13828 
  def write(self, oprot):
13829 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13830 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13831 
      return
13832 
    oprot.writeStructBegin('getSnapdealInventorySnapshot_args')
13833 
    oprot.writeFieldStop()
13834 
    oprot.writeStructEnd()
13835 
 
13836 
  def validate(self):
13837 
    return
13838 
 
13839 
 
13840 
  def __repr__(self):
13841 
    L = ['%s=%r' % (key, value)
13842 
      for key, value in self.__dict__.iteritems()]
13843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13844 
 
13845 
  def __eq__(self, other):
13846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13847 
 
13848 
  def __ne__(self, other):
13849 
    return not (self == other)
13850 
 
13851 
class getSnapdealInventorySnapshot_result:
13852 
  """
13853 
  Attributes:
13854 
   - success
13855 
  """
13856 
 
13857 
  thrift_spec = (
13858 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealInventoryItem, SnapdealInventoryItem.thrift_spec)), None, ), # 0
13859 
  )
13860 
 
13861 
  def __init__(self, success=None,):
13862 
    self.success = success
13863 
 
13864 
  def read(self, iprot):
13865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13867 
      return
13868 
    iprot.readStructBegin()
13869 
    while True:
13870 
      (fname, ftype, fid) = iprot.readFieldBegin()
13871 
      if ftype == TType.STOP:
13872 
        break
13873 
      if fid == 0:
13874 
        if ftype == TType.LIST:
13875 
          self.success = []
11173 vikram.rag 13876 
          (_etype291, _size288) = iprot.readListBegin()
13877 
          for _i292 in xrange(_size288):
13878 
            _elem293 = SnapdealInventoryItem()
13879 
            _elem293.read(iprot)
13880 
            self.success.append(_elem293)
9495 vikram.rag 13881 
          iprot.readListEnd()
13882 
        else:
13883 
          iprot.skip(ftype)
13884 
      else:
13885 
        iprot.skip(ftype)
13886 
      iprot.readFieldEnd()
13887 
    iprot.readStructEnd()
13888 
 
13889 
  def write(self, oprot):
13890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13892 
      return
13893 
    oprot.writeStructBegin('getSnapdealInventorySnapshot_result')
13894 
    if self.success is not None:
13895 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13896 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11173 vikram.rag 13897 
      for iter294 in self.success:
13898 
        iter294.write(oprot)
9495 vikram.rag 13899 
      oprot.writeListEnd()
13900 
      oprot.writeFieldEnd()
13901 
    oprot.writeFieldStop()
13902 
    oprot.writeStructEnd()
13903 
 
13904 
  def validate(self):
13905 
    return
13906 
 
13907 
 
13908 
  def __repr__(self):
13909 
    L = ['%s=%r' % (key, value)
13910 
      for key, value in self.__dict__.iteritems()]
13911 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13912 
 
13913 
  def __eq__(self, other):
13914 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13915 
 
13916 
  def __ne__(self, other):
13917 
    return not (self == other)
9761 amar.kumar 13918 
 
13919 
class getHoldInventoryDetails_args:
13920 
  """
13921 
  Attributes:
13922 
   - itemId
13923 
   - warehouseId
13924 
   - source
13925 
  """
13926 
 
13927 
  thrift_spec = (
13928 
    None, # 0
13929 
    (1, TType.I64, 'itemId', None, None, ), # 1
13930 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
13931 
    (3, TType.I64, 'source', None, None, ), # 3
13932 
  )
13933 
 
13934 
  def __init__(self, itemId=None, warehouseId=None, source=None,):
13935 
    self.itemId = itemId
13936 
    self.warehouseId = warehouseId
13937 
    self.source = source
13938 
 
13939 
  def read(self, iprot):
13940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13942 
      return
13943 
    iprot.readStructBegin()
13944 
    while True:
13945 
      (fname, ftype, fid) = iprot.readFieldBegin()
13946 
      if ftype == TType.STOP:
13947 
        break
13948 
      if fid == 1:
13949 
        if ftype == TType.I64:
13950 
          self.itemId = iprot.readI64();
13951 
        else:
13952 
          iprot.skip(ftype)
13953 
      elif fid == 2:
13954 
        if ftype == TType.I64:
13955 
          self.warehouseId = iprot.readI64();
13956 
        else:
13957 
          iprot.skip(ftype)
13958 
      elif fid == 3:
13959 
        if ftype == TType.I64:
13960 
          self.source = iprot.readI64();
13961 
        else:
13962 
          iprot.skip(ftype)
13963 
      else:
13964 
        iprot.skip(ftype)
13965 
      iprot.readFieldEnd()
13966 
    iprot.readStructEnd()
13967 
 
13968 
  def write(self, oprot):
13969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13971 
      return
13972 
    oprot.writeStructBegin('getHoldInventoryDetails_args')
13973 
    if self.itemId is not None:
13974 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13975 
      oprot.writeI64(self.itemId)
13976 
      oprot.writeFieldEnd()
13977 
    if self.warehouseId is not None:
13978 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13979 
      oprot.writeI64(self.warehouseId)
13980 
      oprot.writeFieldEnd()
13981 
    if self.source is not None:
13982 
      oprot.writeFieldBegin('source', TType.I64, 3)
13983 
      oprot.writeI64(self.source)
13984 
      oprot.writeFieldEnd()
13985 
    oprot.writeFieldStop()
13986 
    oprot.writeStructEnd()
13987 
 
13988 
  def validate(self):
13989 
    return
13990 
 
13991 
 
13992 
  def __repr__(self):
13993 
    L = ['%s=%r' % (key, value)
13994 
      for key, value in self.__dict__.iteritems()]
13995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13996 
 
13997 
  def __eq__(self, other):
13998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13999 
 
14000 
  def __ne__(self, other):
14001 
    return not (self == other)
14002 
 
14003 
class getHoldInventoryDetails_result:
14004 
  """
14005 
  Attributes:
14006 
   - success
14007 
  """
14008 
 
14009 
  thrift_spec = (
14010 
    (0, TType.LIST, 'success', (TType.STRUCT,(HoldInventoryDetail, HoldInventoryDetail.thrift_spec)), None, ), # 0
14011 
  )
14012 
 
14013 
  def __init__(self, success=None,):
14014 
    self.success = success
14015 
 
14016 
  def read(self, iprot):
14017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14019 
      return
14020 
    iprot.readStructBegin()
14021 
    while True:
14022 
      (fname, ftype, fid) = iprot.readFieldBegin()
14023 
      if ftype == TType.STOP:
14024 
        break
14025 
      if fid == 0:
14026 
        if ftype == TType.LIST:
14027 
          self.success = []
11173 vikram.rag 14028 
          (_etype298, _size295) = iprot.readListBegin()
14029 
          for _i299 in xrange(_size295):
14030 
            _elem300 = HoldInventoryDetail()
14031 
            _elem300.read(iprot)
14032 
            self.success.append(_elem300)
9761 amar.kumar 14033 
          iprot.readListEnd()
14034 
        else:
14035 
          iprot.skip(ftype)
14036 
      else:
14037 
        iprot.skip(ftype)
14038 
      iprot.readFieldEnd()
14039 
    iprot.readStructEnd()
14040 
 
14041 
  def write(self, oprot):
14042 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14043 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14044 
      return
14045 
    oprot.writeStructBegin('getHoldInventoryDetails_result')
14046 
    if self.success is not None:
14047 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14048 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11173 vikram.rag 14049 
      for iter301 in self.success:
14050 
        iter301.write(oprot)
9761 amar.kumar 14051 
      oprot.writeListEnd()
14052 
      oprot.writeFieldEnd()
14053 
    oprot.writeFieldStop()
14054 
    oprot.writeStructEnd()
14055 
 
14056 
  def validate(self):
14057 
    return
14058 
 
14059 
 
14060 
  def __repr__(self):
14061 
    L = ['%s=%r' % (key, value)
14062 
      for key, value in self.__dict__.iteritems()]
14063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14064 
 
14065 
  def __eq__(self, other):
14066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14067 
 
14068 
  def __ne__(self, other):
14069 
    return not (self == other)
10050 vikram.rag 14070 
 
14071 
class addOrUpdateFlipkartInventorySnapshot_args:
14072 
  """
14073 
  Attributes:
14074 
   - flipkartInventorySnapshot
10450 vikram.rag 14075 
   - time
10050 vikram.rag 14076 
  """
14077 
 
10450 vikram.rag 14078 
  thrift_spec = (
14079 
    None, # 0
14080 
    (1, TType.LIST, 'flipkartInventorySnapshot', (TType.STRUCT,(FlipkartInventorySnapshot, FlipkartInventorySnapshot.thrift_spec)), None, ), # 1
14081 
    (2, TType.I64, 'time', None, None, ), # 2
14082 
  )
14083 
 
14084 
  def __init__(self, flipkartInventorySnapshot=None, time=None,):
10050 vikram.rag 14085 
    self.flipkartInventorySnapshot = flipkartInventorySnapshot
10450 vikram.rag 14086 
    self.time = time
10050 vikram.rag 14087 
 
14088 
  def read(self, iprot):
14089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14091 
      return
14092 
    iprot.readStructBegin()
14093 
    while True:
14094 
      (fname, ftype, fid) = iprot.readFieldBegin()
14095 
      if ftype == TType.STOP:
14096 
        break
10450 vikram.rag 14097 
      if fid == 1:
10050 vikram.rag 14098 
        if ftype == TType.LIST:
14099 
          self.flipkartInventorySnapshot = []
11173 vikram.rag 14100 
          (_etype305, _size302) = iprot.readListBegin()
14101 
          for _i306 in xrange(_size302):
14102 
            _elem307 = FlipkartInventorySnapshot()
14103 
            _elem307.read(iprot)
14104 
            self.flipkartInventorySnapshot.append(_elem307)
10050 vikram.rag 14105 
          iprot.readListEnd()
14106 
        else:
14107 
          iprot.skip(ftype)
10450 vikram.rag 14108 
      elif fid == 2:
14109 
        if ftype == TType.I64:
14110 
          self.time = iprot.readI64();
14111 
        else:
14112 
          iprot.skip(ftype)
10050 vikram.rag 14113 
      else:
14114 
        iprot.skip(ftype)
14115 
      iprot.readFieldEnd()
14116 
    iprot.readStructEnd()
14117 
 
14118 
  def write(self, oprot):
14119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14121 
      return
14122 
    oprot.writeStructBegin('addOrUpdateFlipkartInventorySnapshot_args')
14123 
    if self.flipkartInventorySnapshot is not None:
10450 vikram.rag 14124 
      oprot.writeFieldBegin('flipkartInventorySnapshot', TType.LIST, 1)
10050 vikram.rag 14125 
      oprot.writeListBegin(TType.STRUCT, len(self.flipkartInventorySnapshot))
11173 vikram.rag 14126 
      for iter308 in self.flipkartInventorySnapshot:
14127 
        iter308.write(oprot)
10050 vikram.rag 14128 
      oprot.writeListEnd()
14129 
      oprot.writeFieldEnd()
10450 vikram.rag 14130 
    if self.time is not None:
14131 
      oprot.writeFieldBegin('time', TType.I64, 2)
14132 
      oprot.writeI64(self.time)
14133 
      oprot.writeFieldEnd()
10050 vikram.rag 14134 
    oprot.writeFieldStop()
14135 
    oprot.writeStructEnd()
14136 
 
14137 
  def validate(self):
14138 
    return
14139 
 
14140 
 
14141 
  def __repr__(self):
14142 
    L = ['%s=%r' % (key, value)
14143 
      for key, value in self.__dict__.iteritems()]
14144 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14145 
 
14146 
  def __eq__(self, other):
14147 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14148 
 
14149 
  def __ne__(self, other):
14150 
    return not (self == other)
14151 
 
14152 
class addOrUpdateFlipkartInventorySnapshot_result:
14153 
 
14154 
  thrift_spec = (
14155 
  )
14156 
 
14157 
  def read(self, iprot):
14158 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14159 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14160 
      return
14161 
    iprot.readStructBegin()
14162 
    while True:
14163 
      (fname, ftype, fid) = iprot.readFieldBegin()
14164 
      if ftype == TType.STOP:
14165 
        break
14166 
      else:
14167 
        iprot.skip(ftype)
14168 
      iprot.readFieldEnd()
14169 
    iprot.readStructEnd()
14170 
 
14171 
  def write(self, oprot):
14172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14174 
      return
14175 
    oprot.writeStructBegin('addOrUpdateFlipkartInventorySnapshot_result')
14176 
    oprot.writeFieldStop()
14177 
    oprot.writeStructEnd()
14178 
 
14179 
  def validate(self):
14180 
    return
14181 
 
14182 
 
14183 
  def __repr__(self):
14184 
    L = ['%s=%r' % (key, value)
14185 
      for key, value in self.__dict__.iteritems()]
14186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14187 
 
14188 
  def __eq__(self, other):
14189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14190 
 
14191 
  def __ne__(self, other):
14192 
    return not (self == other)
14193 
 
14194 
class getFlipkartInventorySnapshot_args:
14195 
 
14196 
  thrift_spec = (
14197 
  )
14198 
 
14199 
  def read(self, iprot):
14200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14202 
      return
14203 
    iprot.readStructBegin()
14204 
    while True:
14205 
      (fname, ftype, fid) = iprot.readFieldBegin()
14206 
      if ftype == TType.STOP:
14207 
        break
14208 
      else:
14209 
        iprot.skip(ftype)
14210 
      iprot.readFieldEnd()
14211 
    iprot.readStructEnd()
14212 
 
14213 
  def write(self, oprot):
14214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14216 
      return
14217 
    oprot.writeStructBegin('getFlipkartInventorySnapshot_args')
14218 
    oprot.writeFieldStop()
14219 
    oprot.writeStructEnd()
14220 
 
14221 
  def validate(self):
14222 
    return
14223 
 
14224 
 
14225 
  def __repr__(self):
14226 
    L = ['%s=%r' % (key, value)
14227 
      for key, value in self.__dict__.iteritems()]
14228 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14229 
 
14230 
  def __eq__(self, other):
14231 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14232 
 
14233 
  def __ne__(self, other):
14234 
    return not (self == other)
14235 
 
14236 
class getFlipkartInventorySnapshot_result:
14237 
  """
14238 
  Attributes:
14239 
   - success
14240 
  """
14241 
 
14242 
  thrift_spec = (
14243 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartInventorySnapshot, FlipkartInventorySnapshot.thrift_spec)), None, ), # 0
14244 
  )
14245 
 
14246 
  def __init__(self, success=None,):
14247 
    self.success = success
14248 
 
14249 
  def read(self, iprot):
14250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14252 
      return
14253 
    iprot.readStructBegin()
14254 
    while True:
14255 
      (fname, ftype, fid) = iprot.readFieldBegin()
14256 
      if ftype == TType.STOP:
14257 
        break
14258 
      if fid == 0:
14259 
        if ftype == TType.LIST:
14260 
          self.success = []
11173 vikram.rag 14261 
          (_etype312, _size309) = iprot.readListBegin()
14262 
          for _i313 in xrange(_size309):
14263 
            _elem314 = FlipkartInventorySnapshot()
14264 
            _elem314.read(iprot)
14265 
            self.success.append(_elem314)
10050 vikram.rag 14266 
          iprot.readListEnd()
14267 
        else:
14268 
          iprot.skip(ftype)
14269 
      else:
14270 
        iprot.skip(ftype)
14271 
      iprot.readFieldEnd()
14272 
    iprot.readStructEnd()
14273 
 
14274 
  def write(self, oprot):
14275 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14276 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14277 
      return
14278 
    oprot.writeStructBegin('getFlipkartInventorySnapshot_result')
14279 
    if self.success is not None:
14280 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14281 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11173 vikram.rag 14282 
      for iter315 in self.success:
14283 
        iter315.write(oprot)
10050 vikram.rag 14284 
      oprot.writeListEnd()
14285 
      oprot.writeFieldEnd()
14286 
    oprot.writeFieldStop()
14287 
    oprot.writeStructEnd()
14288 
 
14289 
  def validate(self):
14290 
    return
14291 
 
14292 
 
14293 
  def __repr__(self):
14294 
    L = ['%s=%r' % (key, value)
14295 
      for key, value in self.__dict__.iteritems()]
14296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14297 
 
14298 
  def __eq__(self, other):
14299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14300 
 
14301 
  def __ne__(self, other):
14302 
    return not (self == other)
10097 kshitij.so 14303 
 
14304 
class getFlipkartlInventoryForItem_args:
14305 
  """
14306 
  Attributes:
14307 
   - item_id
14308 
  """
14309 
 
14310 
  thrift_spec = (
14311 
    None, # 0
14312 
    (1, TType.I64, 'item_id', None, None, ), # 1
14313 
  )
14314 
 
14315 
  def __init__(self, item_id=None,):
14316 
    self.item_id = item_id
14317 
 
14318 
  def read(self, iprot):
14319 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14320 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14321 
      return
14322 
    iprot.readStructBegin()
14323 
    while True:
14324 
      (fname, ftype, fid) = iprot.readFieldBegin()
14325 
      if ftype == TType.STOP:
14326 
        break
14327 
      if fid == 1:
14328 
        if ftype == TType.I64:
14329 
          self.item_id = iprot.readI64();
14330 
        else:
14331 
          iprot.skip(ftype)
14332 
      else:
14333 
        iprot.skip(ftype)
14334 
      iprot.readFieldEnd()
14335 
    iprot.readStructEnd()
14336 
 
14337 
  def write(self, oprot):
14338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14340 
      return
14341 
    oprot.writeStructBegin('getFlipkartlInventoryForItem_args')
14342 
    if self.item_id is not None:
14343 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
14344 
      oprot.writeI64(self.item_id)
14345 
      oprot.writeFieldEnd()
14346 
    oprot.writeFieldStop()
14347 
    oprot.writeStructEnd()
14348 
 
14349 
  def validate(self):
14350 
    return
14351 
 
14352 
 
14353 
  def __repr__(self):
14354 
    L = ['%s=%r' % (key, value)
14355 
      for key, value in self.__dict__.iteritems()]
14356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14357 
 
14358 
  def __eq__(self, other):
14359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14360 
 
14361 
  def __ne__(self, other):
14362 
    return not (self == other)
14363 
 
14364 
class getFlipkartlInventoryForItem_result:
14365 
  """
14366 
  Attributes:
14367 
   - success
14368 
  """
14369 
 
14370 
  thrift_spec = (
14371 
    (0, TType.STRUCT, 'success', (FlipkartInventorySnapshot, FlipkartInventorySnapshot.thrift_spec), None, ), # 0
14372 
  )
14373 
 
14374 
  def __init__(self, success=None,):
14375 
    self.success = success
14376 
 
14377 
  def read(self, iprot):
14378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14380 
      return
14381 
    iprot.readStructBegin()
14382 
    while True:
14383 
      (fname, ftype, fid) = iprot.readFieldBegin()
14384 
      if ftype == TType.STOP:
14385 
        break
14386 
      if fid == 0:
14387 
        if ftype == TType.STRUCT:
14388 
          self.success = FlipkartInventorySnapshot()
14389 
          self.success.read(iprot)
14390 
        else:
14391 
          iprot.skip(ftype)
14392 
      else:
14393 
        iprot.skip(ftype)
14394 
      iprot.readFieldEnd()
14395 
    iprot.readStructEnd()
14396 
 
14397 
  def write(self, oprot):
14398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14400 
      return
14401 
    oprot.writeStructBegin('getFlipkartlInventoryForItem_result')
14402 
    if self.success is not None:
14403 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14404 
      self.success.write(oprot)
14405 
      oprot.writeFieldEnd()
14406 
    oprot.writeFieldStop()
14407 
    oprot.writeStructEnd()
14408 
 
14409 
  def validate(self):
14410 
    return
14411 
 
14412 
 
14413 
  def __repr__(self):
14414 
    L = ['%s=%r' % (key, value)
14415 
      for key, value in self.__dict__.iteritems()]
14416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14417 
 
14418 
  def __eq__(self, other):
14419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14420 
 
14421 
  def __ne__(self, other):
14422 
    return not (self == other)
10485 vikram.rag 14423 
 
14424 
class getStateMaster_args:
14425 
 
14426 
  thrift_spec = (
14427 
  )
14428 
 
14429 
  def read(self, iprot):
14430 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14431 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14432 
      return
14433 
    iprot.readStructBegin()
14434 
    while True:
14435 
      (fname, ftype, fid) = iprot.readFieldBegin()
14436 
      if ftype == TType.STOP:
14437 
        break
14438 
      else:
14439 
        iprot.skip(ftype)
14440 
      iprot.readFieldEnd()
14441 
    iprot.readStructEnd()
14442 
 
14443 
  def write(self, oprot):
14444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14446 
      return
14447 
    oprot.writeStructBegin('getStateMaster_args')
14448 
    oprot.writeFieldStop()
14449 
    oprot.writeStructEnd()
14450 
 
14451 
  def validate(self):
14452 
    return
14453 
 
14454 
 
14455 
  def __repr__(self):
14456 
    L = ['%s=%r' % (key, value)
14457 
      for key, value in self.__dict__.iteritems()]
14458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14459 
 
14460 
  def __eq__(self, other):
14461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14462 
 
14463 
  def __ne__(self, other):
14464 
    return not (self == other)
14465 
 
14466 
class getStateMaster_result:
14467 
  """
14468 
  Attributes:
14469 
   - success
14470 
  """
14471 
 
14472 
  thrift_spec = (
12280 amit.gupta 14473 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRUCT,(StateInfo, StateInfo.thrift_spec)), None, ), # 0
10485 vikram.rag 14474 
  )
14475 
 
14476 
  def __init__(self, success=None,):
14477 
    self.success = success
14478 
 
14479 
  def read(self, iprot):
14480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14482 
      return
14483 
    iprot.readStructBegin()
14484 
    while True:
14485 
      (fname, ftype, fid) = iprot.readFieldBegin()
14486 
      if ftype == TType.STOP:
14487 
        break
14488 
      if fid == 0:
14489 
        if ftype == TType.MAP:
14490 
          self.success = {}
11173 vikram.rag 14491 
          (_ktype317, _vtype318, _size316 ) = iprot.readMapBegin()
14492 
          for _i320 in xrange(_size316):
14493 
            _key321 = iprot.readI64();
12280 amit.gupta 14494 
            _val322 = StateInfo()
14495 
            _val322.read(iprot)
11173 vikram.rag 14496 
            self.success[_key321] = _val322
10485 vikram.rag 14497 
          iprot.readMapEnd()
14498 
        else:
14499 
          iprot.skip(ftype)
14500 
      else:
14501 
        iprot.skip(ftype)
14502 
      iprot.readFieldEnd()
14503 
    iprot.readStructEnd()
14504 
 
14505 
  def write(self, oprot):
14506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14508 
      return
14509 
    oprot.writeStructBegin('getStateMaster_result')
14510 
    if self.success is not None:
14511 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12280 amit.gupta 14512 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.success))
11173 vikram.rag 14513 
      for kiter323,viter324 in self.success.items():
14514 
        oprot.writeI64(kiter323)
12280 amit.gupta 14515 
        viter324.write(oprot)
10485 vikram.rag 14516 
      oprot.writeMapEnd()
14517 
      oprot.writeFieldEnd()
14518 
    oprot.writeFieldStop()
14519 
    oprot.writeStructEnd()
14520 
 
14521 
  def validate(self):
14522 
    return
14523 
 
14524 
 
14525 
  def __repr__(self):
14526 
    L = ['%s=%r' % (key, value)
14527 
      for key, value in self.__dict__.iteritems()]
14528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14529 
 
14530 
  def __eq__(self, other):
14531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14532 
 
14533 
  def __ne__(self, other):
14534 
    return not (self == other)
10544 vikram.rag 14535 
 
14536 
class updateSnapdealStockAtEOD_args:
14537 
  """
14538 
  Attributes:
14539 
   - allsnapdealstock
14540 
  """
14541 
 
14542 
  thrift_spec = None
14543 
  def __init__(self, allsnapdealstock=None,):
14544 
    self.allsnapdealstock = allsnapdealstock
14545 
 
14546 
  def read(self, iprot):
14547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14549 
      return
14550 
    iprot.readStructBegin()
14551 
    while True:
14552 
      (fname, ftype, fid) = iprot.readFieldBegin()
14553 
      if ftype == TType.STOP:
14554 
        break
14555 
      if fid == -1:
14556 
        if ftype == TType.LIST:
14557 
          self.allsnapdealstock = []
11173 vikram.rag 14558 
          (_etype328, _size325) = iprot.readListBegin()
14559 
          for _i329 in xrange(_size325):
14560 
            _elem330 = SnapdealStockAtEOD()
14561 
            _elem330.read(iprot)
14562 
            self.allsnapdealstock.append(_elem330)
10544 vikram.rag 14563 
          iprot.readListEnd()
14564 
        else:
14565 
          iprot.skip(ftype)
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_args')
14576 
    if self.allsnapdealstock is not None:
14577 
      oprot.writeFieldBegin('allsnapdealstock', TType.LIST, -1)
14578 
      oprot.writeListBegin(TType.STRUCT, len(self.allsnapdealstock))
11173 vikram.rag 14579 
      for iter331 in self.allsnapdealstock:
14580 
        iter331.write(oprot)
10544 vikram.rag 14581 
      oprot.writeListEnd()
14582 
      oprot.writeFieldEnd()
14583 
    oprot.writeFieldStop()
14584 
    oprot.writeStructEnd()
14585 
 
14586 
  def validate(self):
14587 
    return
14588 
 
14589 
 
14590 
  def __repr__(self):
14591 
    L = ['%s=%r' % (key, value)
14592 
      for key, value in self.__dict__.iteritems()]
14593 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14594 
 
14595 
  def __eq__(self, other):
14596 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14597 
 
14598 
  def __ne__(self, other):
14599 
    return not (self == other)
14600 
 
14601 
class updateSnapdealStockAtEOD_result:
14602 
 
14603 
  thrift_spec = (
14604 
  )
14605 
 
14606 
  def read(self, iprot):
14607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14609 
      return
14610 
    iprot.readStructBegin()
14611 
    while True:
14612 
      (fname, ftype, fid) = iprot.readFieldBegin()
14613 
      if ftype == TType.STOP:
14614 
        break
14615 
      else:
14616 
        iprot.skip(ftype)
14617 
      iprot.readFieldEnd()
14618 
    iprot.readStructEnd()
14619 
 
14620 
  def write(self, oprot):
14621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14623 
      return
14624 
    oprot.writeStructBegin('updateSnapdealStockAtEOD_result')
14625 
    oprot.writeFieldStop()
14626 
    oprot.writeStructEnd()
14627 
 
14628 
  def validate(self):
14629 
    return
14630 
 
14631 
 
14632 
  def __repr__(self):
14633 
    L = ['%s=%r' % (key, value)
14634 
      for key, value in self.__dict__.iteritems()]
14635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14636 
 
14637 
  def __eq__(self, other):
14638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14639 
 
14640 
  def __ne__(self, other):
14641 
    return not (self == other)
14642 
 
14643 
class updateFlipkartStockAtEOD_args:
14644 
  """
14645 
  Attributes:
14646 
   - allflipkartstock
14647 
  """
14648 
 
14649 
  thrift_spec = None
14650 
  def __init__(self, allflipkartstock=None,):
14651 
    self.allflipkartstock = allflipkartstock
14652 
 
14653 
  def read(self, iprot):
14654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14656 
      return
14657 
    iprot.readStructBegin()
14658 
    while True:
14659 
      (fname, ftype, fid) = iprot.readFieldBegin()
14660 
      if ftype == TType.STOP:
14661 
        break
14662 
      if fid == -1:
14663 
        if ftype == TType.LIST:
14664 
          self.allflipkartstock = []
11173 vikram.rag 14665 
          (_etype335, _size332) = iprot.readListBegin()
14666 
          for _i336 in xrange(_size332):
14667 
            _elem337 = FlipkartStockAtEOD()
14668 
            _elem337.read(iprot)
14669 
            self.allflipkartstock.append(_elem337)
10544 vikram.rag 14670 
          iprot.readListEnd()
14671 
        else:
14672 
          iprot.skip(ftype)
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_args')
14683 
    if self.allflipkartstock is not None:
14684 
      oprot.writeFieldBegin('allflipkartstock', TType.LIST, -1)
14685 
      oprot.writeListBegin(TType.STRUCT, len(self.allflipkartstock))
11173 vikram.rag 14686 
      for iter338 in self.allflipkartstock:
14687 
        iter338.write(oprot)
10544 vikram.rag 14688 
      oprot.writeListEnd()
14689 
      oprot.writeFieldEnd()
14690 
    oprot.writeFieldStop()
14691 
    oprot.writeStructEnd()
14692 
 
14693 
  def validate(self):
14694 
    return
14695 
 
14696 
 
14697 
  def __repr__(self):
14698 
    L = ['%s=%r' % (key, value)
14699 
      for key, value in self.__dict__.iteritems()]
14700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14701 
 
14702 
  def __eq__(self, other):
14703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14704 
 
14705 
  def __ne__(self, other):
14706 
    return not (self == other)
14707 
 
14708 
class updateFlipkartStockAtEOD_result:
14709 
 
14710 
  thrift_spec = (
14711 
  )
14712 
 
14713 
  def read(self, iprot):
14714 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14715 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14716 
      return
14717 
    iprot.readStructBegin()
14718 
    while True:
14719 
      (fname, ftype, fid) = iprot.readFieldBegin()
14720 
      if ftype == TType.STOP:
14721 
        break
14722 
      else:
14723 
        iprot.skip(ftype)
14724 
      iprot.readFieldEnd()
14725 
    iprot.readStructEnd()
14726 
 
14727 
  def write(self, oprot):
14728 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14729 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14730 
      return
14731 
    oprot.writeStructBegin('updateFlipkartStockAtEOD_result')
14732 
    oprot.writeFieldStop()
14733 
    oprot.writeStructEnd()
14734 
 
14735 
  def validate(self):
14736 
    return
14737 
 
14738 
 
14739 
  def __repr__(self):
14740 
    L = ['%s=%r' % (key, value)
14741 
      for key, value in self.__dict__.iteritems()]
14742 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14743 
 
14744 
  def __eq__(self, other):
14745 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14746 
 
14747 
  def __ne__(self, other):
14748 
    return not (self == other)
12363 kshitij.so 14749 
 
14750 
class getWanNlcForSource_args:
14751 
  """
14752 
  Attributes:
14753 
   - item_id
14754 
   - source
14755 
  """
14756 
 
14757 
  thrift_spec = (
14758 
    None, # 0
14759 
    (1, TType.I64, 'item_id', None, None, ), # 1
14760 
    (2, TType.I64, 'source', None, None, ), # 2
14761 
  )
14762 
 
14763 
  def __init__(self, item_id=None, source=None,):
14764 
    self.item_id = item_id
14765 
    self.source = source
14766 
 
14767 
  def read(self, iprot):
14768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14770 
      return
14771 
    iprot.readStructBegin()
14772 
    while True:
14773 
      (fname, ftype, fid) = iprot.readFieldBegin()
14774 
      if ftype == TType.STOP:
14775 
        break
14776 
      if fid == 1:
14777 
        if ftype == TType.I64:
14778 
          self.item_id = iprot.readI64();
14779 
        else:
14780 
          iprot.skip(ftype)
14781 
      elif fid == 2:
14782 
        if ftype == TType.I64:
14783 
          self.source = iprot.readI64();
14784 
        else:
14785 
          iprot.skip(ftype)
14786 
      else:
14787 
        iprot.skip(ftype)
14788 
      iprot.readFieldEnd()
14789 
    iprot.readStructEnd()
14790 
 
14791 
  def write(self, oprot):
14792 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14793 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14794 
      return
14795 
    oprot.writeStructBegin('getWanNlcForSource_args')
14796 
    if self.item_id is not None:
14797 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
14798 
      oprot.writeI64(self.item_id)
14799 
      oprot.writeFieldEnd()
14800 
    if self.source is not None:
14801 
      oprot.writeFieldBegin('source', TType.I64, 2)
14802 
      oprot.writeI64(self.source)
14803 
      oprot.writeFieldEnd()
14804 
    oprot.writeFieldStop()
14805 
    oprot.writeStructEnd()
14806 
 
14807 
  def validate(self):
14808 
    return
14809 
 
14810 
 
14811 
  def __repr__(self):
14812 
    L = ['%s=%r' % (key, value)
14813 
      for key, value in self.__dict__.iteritems()]
14814 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14815 
 
14816 
  def __eq__(self, other):
14817 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14818 
 
14819 
  def __ne__(self, other):
14820 
    return not (self == other)
14821 
 
14822 
class getWanNlcForSource_result:
14823 
  """
14824 
  Attributes:
14825 
   - success
14826 
  """
14827 
 
14828 
  thrift_spec = (
14829 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
14830 
  )
14831 
 
14832 
  def __init__(self, success=None,):
14833 
    self.success = success
14834 
 
14835 
  def read(self, iprot):
14836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14838 
      return
14839 
    iprot.readStructBegin()
14840 
    while True:
14841 
      (fname, ftype, fid) = iprot.readFieldBegin()
14842 
      if ftype == TType.STOP:
14843 
        break
14844 
      if fid == 0:
14845 
        if ftype == TType.DOUBLE:
14846 
          self.success = iprot.readDouble();
14847 
        else:
14848 
          iprot.skip(ftype)
14849 
      else:
14850 
        iprot.skip(ftype)
14851 
      iprot.readFieldEnd()
14852 
    iprot.readStructEnd()
14853 
 
14854 
  def write(self, oprot):
14855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14857 
      return
14858 
    oprot.writeStructBegin('getWanNlcForSource_result')
14859 
    if self.success is not None:
14860 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
14861 
      oprot.writeDouble(self.success)
14862 
      oprot.writeFieldEnd()
14863 
    oprot.writeFieldStop()
14864 
    oprot.writeStructEnd()
14865 
 
14866 
  def validate(self):
14867 
    return
14868 
 
14869 
 
14870 
  def __repr__(self):
14871 
    L = ['%s=%r' % (key, value)
14872 
      for key, value in self.__dict__.iteritems()]
14873 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14874 
 
14875 
  def __eq__(self, other):
14876 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14877 
 
14878 
  def __ne__(self, other):
14879 
    return not (self == other)
14880 
 
14881 
class getAllAvailableAmazonFbaItemInventory_args:
14882 
 
14883 
  thrift_spec = (
14884 
  )
14885 
 
14886 
  def read(self, iprot):
14887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14889 
      return
14890 
    iprot.readStructBegin()
14891 
    while True:
14892 
      (fname, ftype, fid) = iprot.readFieldBegin()
14893 
      if ftype == TType.STOP:
14894 
        break
14895 
      else:
14896 
        iprot.skip(ftype)
14897 
      iprot.readFieldEnd()
14898 
    iprot.readStructEnd()
14899 
 
14900 
  def write(self, oprot):
14901 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14902 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14903 
      return
14904 
    oprot.writeStructBegin('getAllAvailableAmazonFbaItemInventory_args')
14905 
    oprot.writeFieldStop()
14906 
    oprot.writeStructEnd()
14907 
 
14908 
  def validate(self):
14909 
    return
14910 
 
14911 
 
14912 
  def __repr__(self):
14913 
    L = ['%s=%r' % (key, value)
14914 
      for key, value in self.__dict__.iteritems()]
14915 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14916 
 
14917 
  def __eq__(self, other):
14918 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14919 
 
14920 
  def __ne__(self, other):
14921 
    return not (self == other)
14922 
 
14923 
class getAllAvailableAmazonFbaItemInventory_result:
14924 
  """
14925 
  Attributes:
14926 
   - success
14927 
  """
14928 
 
14929 
  thrift_spec = (
14930 
    (0, TType.LIST, 'success', (TType.STRUCT,(AmazonFbaInventorySnapshot, AmazonFbaInventorySnapshot.thrift_spec)), None, ), # 0
14931 
  )
14932 
 
14933 
  def __init__(self, success=None,):
14934 
    self.success = success
14935 
 
14936 
  def read(self, iprot):
14937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14939 
      return
14940 
    iprot.readStructBegin()
14941 
    while True:
14942 
      (fname, ftype, fid) = iprot.readFieldBegin()
14943 
      if ftype == TType.STOP:
14944 
        break
14945 
      if fid == 0:
14946 
        if ftype == TType.LIST:
14947 
          self.success = []
14948 
          (_etype342, _size339) = iprot.readListBegin()
14949 
          for _i343 in xrange(_size339):
14950 
            _elem344 = AmazonFbaInventorySnapshot()
14951 
            _elem344.read(iprot)
14952 
            self.success.append(_elem344)
14953 
          iprot.readListEnd()
14954 
        else:
14955 
          iprot.skip(ftype)
14956 
      else:
14957 
        iprot.skip(ftype)
14958 
      iprot.readFieldEnd()
14959 
    iprot.readStructEnd()
14960 
 
14961 
  def write(self, oprot):
14962 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14963 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14964 
      return
14965 
    oprot.writeStructBegin('getAllAvailableAmazonFbaItemInventory_result')
14966 
    if self.success is not None:
14967 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14968 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
14969 
      for iter345 in self.success:
14970 
        iter345.write(oprot)
14971 
      oprot.writeListEnd()
14972 
      oprot.writeFieldEnd()
14973 
    oprot.writeFieldStop()
14974 
    oprot.writeStructEnd()
14975 
 
14976 
  def validate(self):
14977 
    return
14978 
 
14979 
 
14980 
  def __repr__(self):
14981 
    L = ['%s=%r' % (key, value)
14982 
      for key, value in self.__dict__.iteritems()]
14983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14984 
 
14985 
  def __eq__(self, other):
14986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14987 
 
14988 
  def __ne__(self, other):
14989 
    return not (self == other)
17990 kshitij.so 14990 
 
14991 
class updateItemAvailabilityForItemIds_args:
14992 
  """
14993 
  Attributes:
14994 
   - itemIds
14995 
  """
14996 
 
14997 
  thrift_spec = (
14998 
    None, # 0
14999 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
15000 
  )
15001 
 
15002 
  def __init__(self, itemIds=None,):
15003 
    self.itemIds = itemIds
15004 
 
15005 
  def read(self, iprot):
15006 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15007 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15008 
      return
15009 
    iprot.readStructBegin()
15010 
    while True:
15011 
      (fname, ftype, fid) = iprot.readFieldBegin()
15012 
      if ftype == TType.STOP:
15013 
        break
15014 
      if fid == 1:
15015 
        if ftype == TType.LIST:
15016 
          self.itemIds = []
15017 
          (_etype349, _size346) = iprot.readListBegin()
15018 
          for _i350 in xrange(_size346):
15019 
            _elem351 = iprot.readI64();
15020 
            self.itemIds.append(_elem351)
15021 
          iprot.readListEnd()
15022 
        else:
15023 
          iprot.skip(ftype)
15024 
      else:
15025 
        iprot.skip(ftype)
15026 
      iprot.readFieldEnd()
15027 
    iprot.readStructEnd()
15028 
 
15029 
  def write(self, oprot):
15030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15032 
      return
15033 
    oprot.writeStructBegin('updateItemAvailabilityForItemIds_args')
15034 
    if self.itemIds is not None:
15035 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
15036 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
15037 
      for iter352 in self.itemIds:
15038 
        oprot.writeI64(iter352)
15039 
      oprot.writeListEnd()
15040 
      oprot.writeFieldEnd()
15041 
    oprot.writeFieldStop()
15042 
    oprot.writeStructEnd()
15043 
 
15044 
  def validate(self):
15045 
    return
15046 
 
15047 
 
15048 
  def __repr__(self):
15049 
    L = ['%s=%r' % (key, value)
15050 
      for key, value in self.__dict__.iteritems()]
15051 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15052 
 
15053 
  def __eq__(self, other):
15054 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15055 
 
15056 
  def __ne__(self, other):
15057 
    return not (self == other)
15058 
 
15059 
class updateItemAvailabilityForItemIds_result:
15060 
  """
15061 
  Attributes:
15062 
   - success
15063 
  """
15064 
 
15065 
  thrift_spec = (
15066 
    (0, TType.BOOL, 'success', None, None, ), # 0
15067 
  )
15068 
 
15069 
  def __init__(self, success=None,):
15070 
    self.success = success
15071 
 
15072 
  def read(self, iprot):
15073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15075 
      return
15076 
    iprot.readStructBegin()
15077 
    while True:
15078 
      (fname, ftype, fid) = iprot.readFieldBegin()
15079 
      if ftype == TType.STOP:
15080 
        break
15081 
      if fid == 0:
15082 
        if ftype == TType.BOOL:
15083 
          self.success = iprot.readBool();
15084 
        else:
15085 
          iprot.skip(ftype)
15086 
      else:
15087 
        iprot.skip(ftype)
15088 
      iprot.readFieldEnd()
15089 
    iprot.readStructEnd()
15090 
 
15091 
  def write(self, oprot):
15092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15094 
      return
15095 
    oprot.writeStructBegin('updateItemAvailabilityForItemIds_result')
15096 
    if self.success is not None:
15097 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15098 
      oprot.writeBool(self.success)
15099 
      oprot.writeFieldEnd()
15100 
    oprot.writeFieldStop()
15101 
    oprot.writeStructEnd()
15102 
 
15103 
  def validate(self):
15104 
    return
15105 
 
15106 
 
15107 
  def __repr__(self):
15108 
    L = ['%s=%r' % (key, value)
15109 
      for key, value in self.__dict__.iteritems()]
15110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15111 
 
15112 
  def __eq__(self, other):
15113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15114 
 
15115 
  def __ne__(self, other):
15116 
    return not (self == other)
19247 kshitij.so 15117 
 
15118 
class addVendorItemPricingInBulk_args:
15119 
  """
15120 
  Attributes:
15121 
   - vendorItemPricingList
15122 
  """
15123 
 
15124 
  thrift_spec = (
15125 
    None, # 0
15126 
    (1, TType.LIST, 'vendorItemPricingList', (TType.STRUCT,(VendorItemPricing, VendorItemPricing.thrift_spec)), None, ), # 1
15127 
  )
15128 
 
15129 
  def __init__(self, vendorItemPricingList=None,):
15130 
    self.vendorItemPricingList = vendorItemPricingList
15131 
 
15132 
  def read(self, iprot):
15133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15135 
      return
15136 
    iprot.readStructBegin()
15137 
    while True:
15138 
      (fname, ftype, fid) = iprot.readFieldBegin()
15139 
      if ftype == TType.STOP:
15140 
        break
15141 
      if fid == 1:
15142 
        if ftype == TType.LIST:
15143 
          self.vendorItemPricingList = []
15144 
          (_etype356, _size353) = iprot.readListBegin()
15145 
          for _i357 in xrange(_size353):
15146 
            _elem358 = VendorItemPricing()
15147 
            _elem358.read(iprot)
15148 
            self.vendorItemPricingList.append(_elem358)
15149 
          iprot.readListEnd()
15150 
        else:
15151 
          iprot.skip(ftype)
15152 
      else:
15153 
        iprot.skip(ftype)
15154 
      iprot.readFieldEnd()
15155 
    iprot.readStructEnd()
15156 
 
15157 
  def write(self, oprot):
15158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15160 
      return
15161 
    oprot.writeStructBegin('addVendorItemPricingInBulk_args')
15162 
    if self.vendorItemPricingList is not None:
15163 
      oprot.writeFieldBegin('vendorItemPricingList', TType.LIST, 1)
15164 
      oprot.writeListBegin(TType.STRUCT, len(self.vendorItemPricingList))
15165 
      for iter359 in self.vendorItemPricingList:
15166 
        iter359.write(oprot)
15167 
      oprot.writeListEnd()
15168 
      oprot.writeFieldEnd()
15169 
    oprot.writeFieldStop()
15170 
    oprot.writeStructEnd()
15171 
 
15172 
  def validate(self):
15173 
    return
15174 
 
15175 
 
15176 
  def __repr__(self):
15177 
    L = ['%s=%r' % (key, value)
15178 
      for key, value in self.__dict__.iteritems()]
15179 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15180 
 
15181 
  def __eq__(self, other):
15182 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15183 
 
15184 
  def __ne__(self, other):
15185 
    return not (self == other)
15186 
 
15187 
class addVendorItemPricingInBulk_result:
15188 
  """
15189 
  Attributes:
15190 
   - success
15191 
  """
15192 
 
15193 
  thrift_spec = (
15194 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
15195 
  )
15196 
 
15197 
  def __init__(self, success=None,):
15198 
    self.success = success
15199 
 
15200 
  def read(self, iprot):
15201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15203 
      return
15204 
    iprot.readStructBegin()
15205 
    while True:
15206 
      (fname, ftype, fid) = iprot.readFieldBegin()
15207 
      if ftype == TType.STOP:
15208 
        break
15209 
      if fid == 0:
15210 
        if ftype == TType.LIST:
15211 
          self.success = []
15212 
          (_etype363, _size360) = iprot.readListBegin()
15213 
          for _i364 in xrange(_size360):
15214 
            _elem365 = iprot.readI64();
15215 
            self.success.append(_elem365)
15216 
          iprot.readListEnd()
15217 
        else:
15218 
          iprot.skip(ftype)
15219 
      else:
15220 
        iprot.skip(ftype)
15221 
      iprot.readFieldEnd()
15222 
    iprot.readStructEnd()
15223 
 
15224 
  def write(self, oprot):
15225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15227 
      return
15228 
    oprot.writeStructBegin('addVendorItemPricingInBulk_result')
15229 
    if self.success is not None:
15230 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15231 
      oprot.writeListBegin(TType.I64, len(self.success))
15232 
      for iter366 in self.success:
15233 
        oprot.writeI64(iter366)
15234 
      oprot.writeListEnd()
15235 
      oprot.writeFieldEnd()
15236 
    oprot.writeFieldStop()
15237 
    oprot.writeStructEnd()
15238 
 
15239 
  def validate(self):
15240 
    return
15241 
 
15242 
 
15243 
  def __repr__(self):
15244 
    L = ['%s=%r' % (key, value)
15245 
      for key, value in self.__dict__.iteritems()]
15246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15247 
 
15248 
  def __eq__(self, other):
15249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15250 
 
15251 
  def __ne__(self, other):
15252 
    return not (self == other)
15253 
 
15254 
class addInventoryInBulk_args:
15255 
  """
15256 
  Attributes:
15257 
   - bulkInventoryList
15258 
  """
15259 
 
15260 
  thrift_spec = (
15261 
    None, # 0
15262 
    (1, TType.LIST, 'bulkInventoryList', (TType.STRUCT,(BulkAddInventory, BulkAddInventory.thrift_spec)), None, ), # 1
15263 
  )
15264 
 
15265 
  def __init__(self, bulkInventoryList=None,):
15266 
    self.bulkInventoryList = bulkInventoryList
15267 
 
15268 
  def read(self, iprot):
15269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15271 
      return
15272 
    iprot.readStructBegin()
15273 
    while True:
15274 
      (fname, ftype, fid) = iprot.readFieldBegin()
15275 
      if ftype == TType.STOP:
15276 
        break
15277 
      if fid == 1:
15278 
        if ftype == TType.LIST:
15279 
          self.bulkInventoryList = []
15280 
          (_etype370, _size367) = iprot.readListBegin()
15281 
          for _i371 in xrange(_size367):
15282 
            _elem372 = BulkAddInventory()
15283 
            _elem372.read(iprot)
15284 
            self.bulkInventoryList.append(_elem372)
15285 
          iprot.readListEnd()
15286 
        else:
15287 
          iprot.skip(ftype)
15288 
      else:
15289 
        iprot.skip(ftype)
15290 
      iprot.readFieldEnd()
15291 
    iprot.readStructEnd()
15292 
 
15293 
  def write(self, oprot):
15294 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15295 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15296 
      return
15297 
    oprot.writeStructBegin('addInventoryInBulk_args')
15298 
    if self.bulkInventoryList is not None:
15299 
      oprot.writeFieldBegin('bulkInventoryList', TType.LIST, 1)
15300 
      oprot.writeListBegin(TType.STRUCT, len(self.bulkInventoryList))
15301 
      for iter373 in self.bulkInventoryList:
15302 
        iter373.write(oprot)
15303 
      oprot.writeListEnd()
15304 
      oprot.writeFieldEnd()
15305 
    oprot.writeFieldStop()
15306 
    oprot.writeStructEnd()
15307 
 
15308 
  def validate(self):
15309 
    return
15310 
 
15311 
 
15312 
  def __repr__(self):
15313 
    L = ['%s=%r' % (key, value)
15314 
      for key, value in self.__dict__.iteritems()]
15315 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15316 
 
15317 
  def __eq__(self, other):
15318 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15319 
 
15320 
  def __ne__(self, other):
15321 
    return not (self == other)
15322 
 
15323 
class addInventoryInBulk_result:
15324 
  """
15325 
  Attributes:
15326 
   - cex
15327 
  """
15328 
 
15329 
  thrift_spec = (
15330 
    None, # 0
15331 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
15332 
  )
15333 
 
15334 
  def __init__(self, cex=None,):
15335 
    self.cex = cex
15336 
 
15337 
  def read(self, iprot):
15338 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15339 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15340 
      return
15341 
    iprot.readStructBegin()
15342 
    while True:
15343 
      (fname, ftype, fid) = iprot.readFieldBegin()
15344 
      if ftype == TType.STOP:
15345 
        break
15346 
      if fid == 1:
15347 
        if ftype == TType.STRUCT:
15348 
          self.cex = InventoryServiceException()
15349 
          self.cex.read(iprot)
15350 
        else:
15351 
          iprot.skip(ftype)
15352 
      else:
15353 
        iprot.skip(ftype)
15354 
      iprot.readFieldEnd()
15355 
    iprot.readStructEnd()
15356 
 
15357 
  def write(self, oprot):
15358 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15359 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15360 
      return
15361 
    oprot.writeStructBegin('addInventoryInBulk_result')
15362 
    if self.cex is not None:
15363 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15364 
      self.cex.write(oprot)
15365 
      oprot.writeFieldEnd()
15366 
    oprot.writeFieldStop()
15367 
    oprot.writeStructEnd()
15368 
 
15369 
  def validate(self):
15370 
    return
15371 
 
15372 
 
15373 
  def __repr__(self):
15374 
    L = ['%s=%r' % (key, value)
15375 
      for key, value in self.__dict__.iteritems()]
15376 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15377 
 
15378 
  def __eq__(self, other):
15379 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15380 
 
15381 
  def __ne__(self, other):
15382 
    return not (self == other)
19413 amit.gupta 15383 
 
22717 amit.gupta 15384 
class getFofoAvailability_args:
15385 
  """
15386 
  Attributes:
15387 
   - itemIds
15388 
  """
15389 
 
15390 
  thrift_spec = (
15391 
    None, # 0
15392 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
15393 
  )
15394 
 
15395 
  def __init__(self, itemIds=None,):
15396 
    self.itemIds = itemIds
15397 
 
15398 
  def read(self, iprot):
15399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15401 
      return
15402 
    iprot.readStructBegin()
15403 
    while True:
15404 
      (fname, ftype, fid) = iprot.readFieldBegin()
15405 
      if ftype == TType.STOP:
15406 
        break
15407 
      if fid == 1:
15408 
        if ftype == TType.LIST:
15409 
          self.itemIds = []
15410 
          (_etype377, _size374) = iprot.readListBegin()
15411 
          for _i378 in xrange(_size374):
15412 
            _elem379 = iprot.readI64();
15413 
            self.itemIds.append(_elem379)
15414 
          iprot.readListEnd()
15415 
        else:
15416 
          iprot.skip(ftype)
15417 
      else:
15418 
        iprot.skip(ftype)
15419 
      iprot.readFieldEnd()
15420 
    iprot.readStructEnd()
15421 
 
15422 
  def write(self, oprot):
15423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15425 
      return
15426 
    oprot.writeStructBegin('getFofoAvailability_args')
15427 
    if self.itemIds is not None:
15428 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
15429 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
15430 
      for iter380 in self.itemIds:
15431 
        oprot.writeI64(iter380)
15432 
      oprot.writeListEnd()
15433 
      oprot.writeFieldEnd()
15434 
    oprot.writeFieldStop()
15435 
    oprot.writeStructEnd()
15436 
 
15437 
  def validate(self):
15438 
    return
15439 
 
15440 
 
15441 
  def __repr__(self):
15442 
    L = ['%s=%r' % (key, value)
15443 
      for key, value in self.__dict__.iteritems()]
15444 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15445 
 
15446 
  def __eq__(self, other):
15447 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15448 
 
15449 
  def __ne__(self, other):
15450 
    return not (self == other)
15451 
 
15452 
class getFofoAvailability_result:
15453 
  """
15454 
  Attributes:
15455 
   - success
15456 
  """
15457 
 
15458 
  thrift_spec = (
15459 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
15460 
  )
15461 
 
15462 
  def __init__(self, success=None,):
15463 
    self.success = success
15464 
 
15465 
  def read(self, iprot):
15466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15468 
      return
15469 
    iprot.readStructBegin()
15470 
    while True:
15471 
      (fname, ftype, fid) = iprot.readFieldBegin()
15472 
      if ftype == TType.STOP:
15473 
        break
15474 
      if fid == 0:
15475 
        if ftype == TType.MAP:
15476 
          self.success = {}
15477 
          (_ktype382, _vtype383, _size381 ) = iprot.readMapBegin()
15478 
          for _i385 in xrange(_size381):
15479 
            _key386 = iprot.readI64();
15480 
            _val387 = iprot.readI64();
15481 
            self.success[_key386] = _val387
15482 
          iprot.readMapEnd()
15483 
        else:
15484 
          iprot.skip(ftype)
15485 
      else:
15486 
        iprot.skip(ftype)
15487 
      iprot.readFieldEnd()
15488 
    iprot.readStructEnd()
15489 
 
15490 
  def write(self, oprot):
15491 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15492 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15493 
      return
15494 
    oprot.writeStructBegin('getFofoAvailability_result')
15495 
    if self.success is not None:
15496 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15497 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
15498 
      for kiter388,viter389 in self.success.items():
15499 
        oprot.writeI64(kiter388)
15500 
        oprot.writeI64(viter389)
15501 
      oprot.writeMapEnd()
15502 
      oprot.writeFieldEnd()
15503 
    oprot.writeFieldStop()
15504 
    oprot.writeStructEnd()
15505 
 
15506 
  def validate(self):
15507 
    return
15508 
 
15509 
 
15510 
  def __repr__(self):
15511 
    L = ['%s=%r' % (key, value)
15512 
      for key, value in self.__dict__.iteritems()]
15513 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15514 
 
15515 
  def __eq__(self, other):
15516 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15517 
 
15518 
  def __ne__(self, other):
15519 
    return not (self == other)
15520 
 
19413 amit.gupta 15521 
class getItemLocationAvailabilityCache_args:
15522 
  """
15523 
  Attributes:
15524 
   - itemLocations
15525 
  """
15526 
 
15527 
  thrift_spec = (
15528 
    None, # 0
15529 
    (1, TType.LIST, 'itemLocations', (TType.STRUCT,(ItemLocationAvailability, ItemLocationAvailability.thrift_spec)), None, ), # 1
15530 
  )
15531 
 
15532 
  def __init__(self, itemLocations=None,):
15533 
    self.itemLocations = itemLocations
15534 
 
15535 
  def read(self, iprot):
15536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15538 
      return
15539 
    iprot.readStructBegin()
15540 
    while True:
15541 
      (fname, ftype, fid) = iprot.readFieldBegin()
15542 
      if ftype == TType.STOP:
15543 
        break
15544 
      if fid == 1:
15545 
        if ftype == TType.LIST:
15546 
          self.itemLocations = []
22717 amit.gupta 15547 
          (_etype393, _size390) = iprot.readListBegin()
15548 
          for _i394 in xrange(_size390):
15549 
            _elem395 = ItemLocationAvailability()
15550 
            _elem395.read(iprot)
15551 
            self.itemLocations.append(_elem395)
19413 amit.gupta 15552 
          iprot.readListEnd()
15553 
        else:
15554 
          iprot.skip(ftype)
15555 
      else:
15556 
        iprot.skip(ftype)
15557 
      iprot.readFieldEnd()
15558 
    iprot.readStructEnd()
15559 
 
15560 
  def write(self, oprot):
15561 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15562 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15563 
      return
15564 
    oprot.writeStructBegin('getItemLocationAvailabilityCache_args')
15565 
    if self.itemLocations is not None:
15566 
      oprot.writeFieldBegin('itemLocations', TType.LIST, 1)
15567 
      oprot.writeListBegin(TType.STRUCT, len(self.itemLocations))
22717 amit.gupta 15568 
      for iter396 in self.itemLocations:
15569 
        iter396.write(oprot)
19413 amit.gupta 15570 
      oprot.writeListEnd()
15571 
      oprot.writeFieldEnd()
15572 
    oprot.writeFieldStop()
15573 
    oprot.writeStructEnd()
15574 
 
15575 
  def validate(self):
15576 
    return
15577 
 
15578 
 
15579 
  def __repr__(self):
15580 
    L = ['%s=%r' % (key, value)
15581 
      for key, value in self.__dict__.iteritems()]
15582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15583 
 
15584 
  def __eq__(self, other):
15585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15586 
 
15587 
  def __ne__(self, other):
15588 
    return not (self == other)
15589 
 
15590 
class getItemLocationAvailabilityCache_result:
15591 
  """
15592 
  Attributes:
15593 
   - success
15594 
  """
15595 
 
15596 
  thrift_spec = (
15597 
    (0, TType.LIST, 'success', (TType.STRUCT,(ItemLocationAvailability, ItemLocationAvailability.thrift_spec)), None, ), # 0
15598 
  )
15599 
 
15600 
  def __init__(self, success=None,):
15601 
    self.success = success
15602 
 
15603 
  def read(self, iprot):
15604 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15605 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15606 
      return
15607 
    iprot.readStructBegin()
15608 
    while True:
15609 
      (fname, ftype, fid) = iprot.readFieldBegin()
15610 
      if ftype == TType.STOP:
15611 
        break
15612 
      if fid == 0:
15613 
        if ftype == TType.LIST:
15614 
          self.success = []
22717 amit.gupta 15615 
          (_etype400, _size397) = iprot.readListBegin()
15616 
          for _i401 in xrange(_size397):
15617 
            _elem402 = ItemLocationAvailability()
15618 
            _elem402.read(iprot)
15619 
            self.success.append(_elem402)
19413 amit.gupta 15620 
          iprot.readListEnd()
15621 
        else:
15622 
          iprot.skip(ftype)
15623 
      else:
15624 
        iprot.skip(ftype)
15625 
      iprot.readFieldEnd()
15626 
    iprot.readStructEnd()
15627 
 
15628 
  def write(self, oprot):
15629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15631 
      return
15632 
    oprot.writeStructBegin('getItemLocationAvailabilityCache_result')
15633 
    if self.success is not None:
15634 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15635 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
22717 amit.gupta 15636 
      for iter403 in self.success:
15637 
        iter403.write(oprot)
19413 amit.gupta 15638 
      oprot.writeListEnd()
15639 
      oprot.writeFieldEnd()
15640 
    oprot.writeFieldStop()
15641 
    oprot.writeStructEnd()
15642 
 
15643 
  def validate(self):
15644 
    return
15645 
 
15646 
 
15647 
  def __repr__(self):
15648 
    L = ['%s=%r' % (key, value)
15649 
      for key, value in self.__dict__.iteritems()]
15650 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15651 
 
15652 
  def __eq__(self, other):
15653 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15654 
 
15655 
  def __ne__(self, other):
15656 
    return not (self == other)
15657 
 
15658 
class getItemLocationAvailabilityCacheByItemId_args:
15659 
  """
15660 
  Attributes:
15661 
   - itemIds
15662 
  """
15663 
 
15664 
  thrift_spec = (
15665 
    None, # 0
15666 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
15667 
  )
15668 
 
15669 
  def __init__(self, itemIds=None,):
15670 
    self.itemIds = itemIds
15671 
 
15672 
  def read(self, iprot):
15673 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15674 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15675 
      return
15676 
    iprot.readStructBegin()
15677 
    while True:
15678 
      (fname, ftype, fid) = iprot.readFieldBegin()
15679 
      if ftype == TType.STOP:
15680 
        break
15681 
      if fid == 1:
15682 
        if ftype == TType.LIST:
15683 
          self.itemIds = []
22717 amit.gupta 15684 
          (_etype407, _size404) = iprot.readListBegin()
15685 
          for _i408 in xrange(_size404):
15686 
            _elem409 = iprot.readI64();
15687 
            self.itemIds.append(_elem409)
19413 amit.gupta 15688 
          iprot.readListEnd()
15689 
        else:
15690 
          iprot.skip(ftype)
15691 
      else:
15692 
        iprot.skip(ftype)
15693 
      iprot.readFieldEnd()
15694 
    iprot.readStructEnd()
15695 
 
15696 
  def write(self, oprot):
15697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15699 
      return
15700 
    oprot.writeStructBegin('getItemLocationAvailabilityCacheByItemId_args')
15701 
    if self.itemIds is not None:
15702 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
15703 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
22717 amit.gupta 15704 
      for iter410 in self.itemIds:
15705 
        oprot.writeI64(iter410)
19413 amit.gupta 15706 
      oprot.writeListEnd()
15707 
      oprot.writeFieldEnd()
15708 
    oprot.writeFieldStop()
15709 
    oprot.writeStructEnd()
15710 
 
15711 
  def validate(self):
15712 
    return
15713 
 
15714 
 
15715 
  def __repr__(self):
15716 
    L = ['%s=%r' % (key, value)
15717 
      for key, value in self.__dict__.iteritems()]
15718 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15719 
 
15720 
  def __eq__(self, other):
15721 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15722 
 
15723 
  def __ne__(self, other):
15724 
    return not (self == other)
15725 
 
15726 
class getItemLocationAvailabilityCacheByItemId_result:
15727 
  """
15728 
  Attributes:
15729 
   - success
15730 
  """
15731 
 
15732 
  thrift_spec = (
15733 
    (0, TType.LIST, 'success', (TType.STRUCT,(ItemLocationAvailability, ItemLocationAvailability.thrift_spec)), None, ), # 0
15734 
  )
15735 
 
15736 
  def __init__(self, success=None,):
15737 
    self.success = success
15738 
 
15739 
  def read(self, iprot):
15740 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15741 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15742 
      return
15743 
    iprot.readStructBegin()
15744 
    while True:
15745 
      (fname, ftype, fid) = iprot.readFieldBegin()
15746 
      if ftype == TType.STOP:
15747 
        break
15748 
      if fid == 0:
15749 
        if ftype == TType.LIST:
15750 
          self.success = []
22717 amit.gupta 15751 
          (_etype414, _size411) = iprot.readListBegin()
15752 
          for _i415 in xrange(_size411):
15753 
            _elem416 = ItemLocationAvailability()
15754 
            _elem416.read(iprot)
15755 
            self.success.append(_elem416)
19413 amit.gupta 15756 
          iprot.readListEnd()
15757 
        else:
15758 
          iprot.skip(ftype)
15759 
      else:
15760 
        iprot.skip(ftype)
15761 
      iprot.readFieldEnd()
15762 
    iprot.readStructEnd()
15763 
 
15764 
  def write(self, oprot):
15765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15767 
      return
15768 
    oprot.writeStructBegin('getItemLocationAvailabilityCacheByItemId_result')
15769 
    if self.success is not None:
15770 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15771 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
22717 amit.gupta 15772 
      for iter417 in self.success:
15773 
        iter417.write(oprot)
19413 amit.gupta 15774 
      oprot.writeListEnd()
15775 
      oprot.writeFieldEnd()
15776 
    oprot.writeFieldStop()
15777 
    oprot.writeStructEnd()
15778 
 
15779 
  def validate(self):
15780 
    return
15781 
 
15782 
 
15783 
  def __repr__(self):
15784 
    L = ['%s=%r' % (key, value)
15785 
      for key, value in self.__dict__.iteritems()]
15786 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15787 
 
15788 
  def __eq__(self, other):
15789 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15790 
 
15791 
  def __ne__(self, other):
15792 
    return not (self == other)
15793 
 
15794 
class getItemPincodeAvailability_args:
15795 
  """
15796 
  Attributes:
19416 amit.gupta 15797 
   - itempricing
19413 amit.gupta 15798 
   - pincode
15799 
  """
15800 
 
15801 
  thrift_spec = (
15802 
    None, # 0
19416 amit.gupta 15803 
    (1, TType.MAP, 'itempricing', (TType.I64,None,TType.I64,None), None, ), # 1
19413 amit.gupta 15804 
    (2, TType.STRING, 'pincode', None, None, ), # 2
15805 
  )
15806 
 
19416 amit.gupta 15807 
  def __init__(self, itempricing=None, pincode=None,):
15808 
    self.itempricing = itempricing
19413 amit.gupta 15809 
    self.pincode = pincode
15810 
 
15811 
  def read(self, iprot):
15812 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15813 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15814 
      return
15815 
    iprot.readStructBegin()
15816 
    while True:
15817 
      (fname, ftype, fid) = iprot.readFieldBegin()
15818 
      if ftype == TType.STOP:
15819 
        break
15820 
      if fid == 1:
19416 amit.gupta 15821 
        if ftype == TType.MAP:
15822 
          self.itempricing = {}
22717 amit.gupta 15823 
          (_ktype419, _vtype420, _size418 ) = iprot.readMapBegin()
15824 
          for _i422 in xrange(_size418):
15825 
            _key423 = iprot.readI64();
15826 
            _val424 = iprot.readI64();
15827 
            self.itempricing[_key423] = _val424
19416 amit.gupta 15828 
          iprot.readMapEnd()
19413 amit.gupta 15829 
        else:
15830 
          iprot.skip(ftype)
15831 
      elif fid == 2:
15832 
        if ftype == TType.STRING:
15833 
          self.pincode = iprot.readString();
15834 
        else:
15835 
          iprot.skip(ftype)
15836 
      else:
15837 
        iprot.skip(ftype)
15838 
      iprot.readFieldEnd()
15839 
    iprot.readStructEnd()
15840 
 
15841 
  def write(self, oprot):
15842 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15843 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15844 
      return
15845 
    oprot.writeStructBegin('getItemPincodeAvailability_args')
19416 amit.gupta 15846 
    if self.itempricing is not None:
15847 
      oprot.writeFieldBegin('itempricing', TType.MAP, 1)
15848 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.itempricing))
22717 amit.gupta 15849 
      for kiter425,viter426 in self.itempricing.items():
15850 
        oprot.writeI64(kiter425)
15851 
        oprot.writeI64(viter426)
19416 amit.gupta 15852 
      oprot.writeMapEnd()
19413 amit.gupta 15853 
      oprot.writeFieldEnd()
15854 
    if self.pincode is not None:
15855 
      oprot.writeFieldBegin('pincode', TType.STRING, 2)
15856 
      oprot.writeString(self.pincode)
15857 
      oprot.writeFieldEnd()
15858 
    oprot.writeFieldStop()
15859 
    oprot.writeStructEnd()
15860 
 
15861 
  def validate(self):
15862 
    return
15863 
 
15864 
 
15865 
  def __repr__(self):
15866 
    L = ['%s=%r' % (key, value)
15867 
      for key, value in self.__dict__.iteritems()]
15868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15869 
 
15870 
  def __eq__(self, other):
15871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15872 
 
15873 
  def __ne__(self, other):
15874 
    return not (self == other)
15875 
 
15876 
class getItemPincodeAvailability_result:
15877 
  """
15878 
  Attributes:
15879 
   - success
15880 
  """
15881 
 
15882 
  thrift_spec = (
15883 
    (0, TType.STRING, 'success', None, None, ), # 0
15884 
  )
15885 
 
15886 
  def __init__(self, success=None,):
15887 
    self.success = success
15888 
 
15889 
  def read(self, iprot):
15890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15892 
      return
15893 
    iprot.readStructBegin()
15894 
    while True:
15895 
      (fname, ftype, fid) = iprot.readFieldBegin()
15896 
      if ftype == TType.STOP:
15897 
        break
15898 
      if fid == 0:
15899 
        if ftype == TType.STRING:
15900 
          self.success = iprot.readString();
15901 
        else:
15902 
          iprot.skip(ftype)
15903 
      else:
15904 
        iprot.skip(ftype)
15905 
      iprot.readFieldEnd()
15906 
    iprot.readStructEnd()
15907 
 
15908 
  def write(self, oprot):
15909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15911 
      return
15912 
    oprot.writeStructBegin('getItemPincodeAvailability_result')
15913 
    if self.success is not None:
15914 
      oprot.writeFieldBegin('success', TType.STRING, 0)
15915 
      oprot.writeString(self.success)
15916 
      oprot.writeFieldEnd()
15917 
    oprot.writeFieldStop()
15918 
    oprot.writeStructEnd()
15919 
 
15920 
  def validate(self):
15921 
    return
15922 
 
15923 
 
15924 
  def __repr__(self):
15925 
    L = ['%s=%r' % (key, value)
15926 
      for key, value in self.__dict__.iteritems()]
15927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15928 
 
15929 
  def __eq__(self, other):
15930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15931 
 
15932 
  def __ne__(self, other):
15933 
    return not (self == other)