Subversion Repositories SmartDukaan

Rev

Rev 22721 | 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 
 
23446 amit.gupta 91 
  def getItemAvailabilityAtLocation(self, itemId, sourceId, stateId):
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
23446 amit.gupta 106 
     - stateId
5944 mandeep.dh 107 
    """
108 
    pass
109 
 
110 
  def getAllWarehouses(self, isActive):
111 
    """
112 
    Parameters:
113 
     - isActive
114 
    """
115 
    pass
116 
 
117 
  def getWarehouse(self, warehouse_id):
118 
    """
119 
    Returns the warehouse with the given id.
120 
 
121 
    Parameters:
122 
     - warehouse_id
123 
    """
124 
    pass
125 
 
126 
  def getAllItemsForWarehouse(self, warehouse_id):
127 
    """
128 
    Parameters:
129 
     - warehouse_id
130 
    """
131 
    pass
132 
 
5966 rajveer 133 
  def isOrderBillable(self, itemId, warehouseId, sourceId, orderId):
5944 mandeep.dh 134 
    """
5966 rajveer 135 
    Depending on reservation in the table, verify if we can bill this order or not.
136 
 
137 
    Parameters:
138 
     - itemId
139 
     - warehouseId
140 
     - sourceId
141 
     - orderId
142 
    """
143 
    pass
144 
 
145 
  def reserveItemInWarehouse(self, itemId, warehouseId, sourceId, orderId, createdTimestamp, promisedShippingTimestamp, quantity):
146 
    """
5944 mandeep.dh 147 
    Increases the reservation count for an item in a warehouse. Should always succeed normally.
148 
 
149 
    Parameters:
150 
     - itemId
151 
     - warehouseId
5966 rajveer 152 
     - sourceId
153 
     - orderId
154 
     - createdTimestamp
155 
     - promisedShippingTimestamp
5944 mandeep.dh 156 
     - quantity
157 
    """
158 
    pass
159 
 
7968 amar.kumar 160 
  def updateReservationForOrder(self, itemId, warehouseId, sourceId, orderId, createdTimestamp, promisedShippingTimestamp, quantity):
161 
    """
162 
    Updates the reservation for Order
163 
 
164 
    Parameters:
165 
     - itemId
166 
     - warehouseId
167 
     - sourceId
168 
     - orderId
169 
     - createdTimestamp
170 
     - promisedShippingTimestamp
171 
     - quantity
172 
    """
173 
    pass
174 
 
5966 rajveer 175 
  def reduceReservationCount(self, itemId, warehouseId, sourceId, orderId, quantity):
5944 mandeep.dh 176 
    """
177 
    Decreases the reservation count for an item in a warehouse. Should always succeed normally.
178 
 
179 
    Parameters:
180 
     - itemId
181 
     - warehouseId
5966 rajveer 182 
     - sourceId
183 
     - orderId
5944 mandeep.dh 184 
     - quantity
185 
    """
186 
    pass
187 
 
188 
  def getItemPricing(self, itemId, vendorId):
189 
    """
190 
    Returns the pricing information of an item associated with the vendor of the given warehouse.
191 
    Raises an exception if either the item, vendor or the associated pricing information can't be found.
192 
 
193 
    Parameters:
194 
     - itemId
195 
     - vendorId
196 
    """
197 
    pass
198 
 
199 
  def getAllItemPricing(self, itemId):
200 
    """
201 
    Returns the list of vendor pricing information of an item.
202 
    Raises an exception if item not found corresponding to itemId
203 
 
204 
    Parameters:
205 
     - itemId
206 
    """
207 
    pass
208 
 
209 
  def addVendorItemPricing(self, vendorItemPricing):
210 
    """
211 
    Adds vendor prices corresponding to the item. If pricing already exists then updates the prices.
212 
    Raises an exception if either the item or vendor can't be found corresponding to their ids.
213 
 
214 
    Parameters:
215 
     - vendorItemPricing
216 
    """
217 
    pass
218 
 
219 
  def getVendor(self, vendorId):
220 
    """
221 
    Returns a vendor given its id
222 
 
223 
    Parameters:
224 
     - vendorId
225 
    """
226 
    pass
227 
 
228 
  def getAllVendors(self, ):
229 
    """
230 
    Return list of all vendors
231 
    """
232 
    pass
233 
 
234 
  def addVendorItemMapping(self, key, vendorItemMapping):
235 
    """
236 
    Adds VendorItemMapping. Updates VendorItemMapping if exists corresponding to the item key.
237 
 
238 
    Parameters:
239 
     - key
240 
     - vendorItemMapping
241 
    """
242 
    pass
243 
 
244 
  def getVendorItemMappings(self, itemId):
245 
    """
246 
    Returns the list of vendor item mapping corresponding to itemId passed as parameter.
247 
    Raises an exception if item not found corresponding to itemId
248 
 
249 
    Parameters:
250 
     - itemId
251 
    """
252 
    pass
253 
 
254 
  def getPendingOrdersInventory(self, vendorid):
255 
    """
256 
    Returns a list of inventory stock for items for which there are pending orders for the given vendor.
257 
 
258 
    Parameters:
259 
     - vendorid
260 
    """
261 
    pass
262 
 
263 
  def getWarehouses(self, warehouseType, inventoryType, vendorId, billingWarehouseId, shippingWarehouseId):
264 
    """
265 
    This method returns all warehouses for a given warehosueType, inventoryType, vendor, billingWarehouse and shippingWarehouse.
266 
    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
267 
    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
268 
       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
269 
       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
270 
 
271 
    Parameters:
272 
     - warehouseType
273 
     - inventoryType
274 
     - vendorId
275 
     - billingWarehouseId
276 
     - shippingWarehouseId
277 
    """
278 
    pass
279 
 
280 
  def resetAvailability(self, itemKey, vendorId, quantity, warehouseId):
281 
    """
282 
    Resets availability of an item to the quantity mentioned in a warehouse.
283 
 
284 
    Parameters:
285 
     - itemKey
286 
     - vendorId
287 
     - quantity
288 
     - warehouseId
289 
    """
290 
    pass
291 
 
292 
  def resetAvailabilityForWarehouse(self, warehouseId):
293 
    """
294 
    Resets availability of a warehouse to zero.
295 
 
296 
    Parameters:
297 
     - warehouseId
298 
    """
299 
    pass
300 
 
301 
  def getItemKeysToBeProcessed(self, warehouseId):
302 
    """
303 
    Returns the list of item keys which need to be processed for a given warehouse.
304 
    This is currently used by Support application to send item keys whose inventory needs
305 
    to be updated from PLB
306 
 
307 
    Parameters:
308 
     - warehouseId
309 
    """
310 
    pass
311 
 
312 
  def markMissedInventoryUpdatesAsProcessed(self, itemKey, warehouseId):
313 
    """
314 
    Marks/Deletes missed inventory updates for a given key and warehouse.
315 
    This generally happens when updates from PLB are applied on the currentinventorysnapshot for an item
316 
 
317 
    Parameters:
318 
     - itemKey
319 
     - warehouseId
320 
    """
321 
    pass
322 
 
323 
  def getIgnoredItemKeys(self, ):
324 
    """
325 
    Returns all the item key mappings that have been ignored until date. Value of map has the warehouse id
326 
    and the timestamp from where alert was raised.
327 
    """
328 
    pass
329 
 
330 
  def addBadInventory(self, itemId, warehouseId, quantity):
331 
    """
332 
    Add the BAD type inventory to existing stock.
333 
 
334 
    Parameters:
335 
     - itemId
336 
     - warehouseId
337 
     - quantity
338 
    """
339 
    pass
340 
 
341 
  def getShippingLocations(self, ):
342 
    """
343 
    Returns all shipping locations
344 
    """
345 
    pass
346 
 
347 
  def getAllVendorItemMappings(self, ):
348 
    """
349 
    Fetches all the vendor item mappings present.
350 
    """
351 
    pass
352 
 
353 
  def getInventorySnapshot(self, warehouseId):
354 
    """
355 
    Gets items' inventory for a warehouse
356 
    If warehouse is passed as zero, items' inventory across all warehouses is sent
357 
 
358 
    Parameters:
359 
     - warehouseId
360 
    """
361 
    pass
362 
 
363 
  def clearItemAvailabilityCache(self, ):
364 
    """
365 
    Clear item availability cache.
366 
    """
367 
    pass
368 
 
369 
  def updateVendorString(self, warehouseId, vendorString):
370 
    """
371 
    Parameters:
372 
     - warehouseId
373 
     - vendorString
374 
    """
375 
    pass
376 
 
6096 amit.gupta 377 
  def clearItemAvailabilityCacheForItem(self, item_id):
378 
    """
379 
    Parameters:
380 
     - item_id
381 
    """
382 
    pass
5944 mandeep.dh 383 
 
7718 amar.kumar 384 
  def getOurWarehouseIdForVendor(self, vendorId, billingWarehouseId):
6467 amar.kumar 385 
    """
386 
    Parameters:
387 
     - vendorId
7718 amar.kumar 388 
     - billingWarehouseId
6467 amar.kumar 389 
    """
390 
    pass
6096 amit.gupta 391 
 
6484 amar.kumar 392 
  def getItemAvailabilitiesAtOurWarehouses(self, item_ids):
393 
    """
394 
    Parameters:
395 
     - item_ids
396 
    """
397 
    pass
6467 amar.kumar 398 
 
6531 vikram.rag 399 
  def getMonitoredWarehouseForVendors(self, vendorIds):
400 
    """
401 
    Parameters:
402 
     - vendorIds
403 
    """
404 
    pass
6484 amar.kumar 405 
 
6531 vikram.rag 406 
  def getIgnoredWarehouseidsAndItemids(self, ):
407 
    pass
408 
 
409 
  def insertItemtoIgnoreInventoryUpdatelist(self, item_id, warehouse_id):
410 
    """
411 
    Parameters:
412 
     - item_id
413 
     - warehouse_id
414 
    """
415 
    pass
416 
 
417 
  def deleteItemFromIgnoredInventoryUpdateList(self, item_id, warehouse_id):
418 
    """
419 
    Parameters:
420 
     - item_id
421 
     - warehouse_id
422 
    """
423 
    pass
424 
 
425 
  def getAllIgnoredInventoryupdateItemsCount(self, ):
426 
    pass
427 
 
428 
  def getIgnoredInventoryUpdateItemids(self, offset, limit):
429 
    """
430 
    Parameters:
431 
     - offset
432 
     - limit
433 
    """
434 
    pass
435 
 
6821 amar.kumar 436 
  def updateItemStockPurchaseParams(self, item_id, numOfDaysStock, minStockLevel):
437 
    """
438 
    Parameters:
439 
     - item_id
440 
     - numOfDaysStock
441 
     - minStockLevel
442 
    """
443 
    pass
6531 vikram.rag 444 
 
6821 amar.kumar 445 
  def getItemStockPurchaseParams(self, itemId):
446 
    """
447 
    Parameters:
448 
     - itemId
449 
    """
450 
    pass
451 
 
452 
  def addOosStatusForItem(self, oosStatusMap, date):
453 
    """
454 
    Parameters:
455 
     - oosStatusMap
456 
     - date
457 
    """
458 
    pass
459 
 
9762 amar.kumar 460 
  def getOosStatusesForXDaysForItem(self, itemId, sourceId, days):
6832 amar.kumar 461 
    """
462 
    Parameters:
463 
     - itemId
9762 amar.kumar 464 
     - sourceId
6832 amar.kumar 465 
     - days
466 
    """
467 
    pass
6821 amar.kumar 468 
 
10126 amar.kumar 469 
  def getOosStatusesForXDays(self, sourceId, days):
470 
    """
471 
    Parameters:
472 
     - sourceId
473 
     - days
474 
    """
475 
    pass
476 
 
477 
  def getAllVendorItemPricing(self, itemId, vendorId):
478 
    """
479 
    Parameters:
480 
     - itemId
481 
     - vendorId
482 
    """
483 
    pass
484 
 
6857 amar.kumar 485 
  def getNonZeroItemStockPurchaseParams(self, ):
486 
    pass
6832 amar.kumar 487 
 
7149 amar.kumar 488 
  def getBillableInventoryAndPendingOrders(self, ):
489 
    """
490 
    Returns a list of inventory stock for items for which there are pending orders or have billable inventory.
491 
    """
492 
    pass
6857 amar.kumar 493 
 
7281 kshitij.so 494 
  def getWarehouseName(self, warehouse_id):
495 
    """
496 
    Parameters:
497 
     - warehouse_id
498 
    """
499 
    pass
7149 amar.kumar 500 
 
7281 kshitij.so 501 
  def getAmazonInventoryForItem(self, item_id):
502 
    """
503 
    Parameters:
504 
     - item_id
505 
    """
506 
    pass
507 
 
508 
  def getAllAmazonInventory(self, ):
509 
    pass
510 
 
10450 vikram.rag 511 
  def addOrUpdateAmazonInventoryForItem(self, amazonInventorySnapshot, time):
7281 kshitij.so 512 
    """
513 
    Parameters:
514 
     - amazonInventorySnapshot
10450 vikram.rag 515 
     - time
7281 kshitij.so 516 
    """
517 
    pass
518 
 
7972 amar.kumar 519 
  def getLastNdaySaleForItem(self, itemId, numberOfDays):
520 
    """
521 
    Parameters:
522 
     - itemId
523 
     - numberOfDays
524 
    """
525 
    pass
7281 kshitij.so 526 
 
8282 kshitij.so 527 
  def addOrUpdateAmazonFbaInventory(self, amazonfbainventorysnapshot):
528 
    """
529 
    Parameters:
530 
     - amazonfbainventorysnapshot
531 
    """
532 
    pass
533 
 
8182 amar.kumar 534 
  def addUpdateHoldInventory(self, itemId, warehouseId, holdQuantity, source):
535 
    """
536 
    Parameters:
537 
     - itemId
538 
     - warehouseId
539 
     - holdQuantity
540 
     - source
541 
    """
542 
    pass
7972 amar.kumar 543 
 
8282 kshitij.so 544 
  def getAmazonFbaItemInventory(self, itemId):
545 
    """
546 
    Parameters:
547 
     - itemId
548 
    """
549 
    pass
8182 amar.kumar 550 
 
8363 vikram.rag 551 
  def getAllAmazonFbaItemInventory(self, ):
8282 kshitij.so 552 
    pass
553 
 
8363 vikram.rag 554 
  def getOursGoodWarehouseIdsForLocation(self, state_id):
555 
    """
556 
    Parameters:
557 
     - state_id
558 
    """
559 
    pass
8282 kshitij.so 560 
 
8955 vikram.rag 561 
  def getHoldInventoryDetailForItemForWarehouseIdExceptSource(self, id, warehouse_id, source):
562 
    """
563 
    Parameters:
564 
     - id
565 
     - warehouse_id
566 
     - source
567 
    """
568 
    pass
8363 vikram.rag 569 
 
9404 vikram.rag 570 
  def getSnapdealInventoryForItem(self, item_id):
571 
    """
572 
    Parameters:
573 
     - item_id
574 
    """
575 
    pass
8955 vikram.rag 576 
 
9404 vikram.rag 577 
  def addOrUpdateSnapdealInventoryForItem(self, snapdealinventoryitem):
578 
    """
579 
    Parameters:
580 
     - snapdealinventoryitem
581 
    """
582 
    pass
583 
 
584 
  def getNlcForWarehouse(self, warehouse_id, item_id):
585 
    """
586 
    Parameters:
587 
     - warehouse_id
588 
     - item_id
589 
    """
590 
    pass
591 
 
9640 amar.kumar 592 
  def getHeldInventoryMapForItem(self, item_id, warehouse_id):
593 
    """
594 
    Parameters:
595 
     - item_id
596 
     - warehouse_id
597 
    """
598 
    pass
599 
 
9482 vikram.rag 600 
  def addOrUpdateAllAmazonFbaInventory(self, allamazonfbainventorysnapshot):
601 
    """
602 
    Parameters:
603 
     - allamazonfbainventorysnapshot
604 
    """
605 
    pass
9456 vikram.rag 606 
 
9495 vikram.rag 607 
  def addOrUpdateAllSnapdealInventory(self, allsnapdealinventorysnapshot):
608 
    """
609 
    Parameters:
610 
     - allsnapdealinventorysnapshot
611 
    """
612 
    pass
9482 vikram.rag 613 
 
9495 vikram.rag 614 
  def getSnapdealInventorySnapshot(self, ):
615 
    pass
616 
 
9761 amar.kumar 617 
  def getHoldInventoryDetails(self, itemId, warehouseId, source):
618 
    """
619 
    Parameters:
620 
     - itemId
621 
     - warehouseId
622 
     - source
623 
    """
624 
    pass
9495 vikram.rag 625 
 
10450 vikram.rag 626 
  def addOrUpdateFlipkartInventorySnapshot(self, flipkartInventorySnapshot, time):
10050 vikram.rag 627 
    """
628 
    Parameters:
629 
     - flipkartInventorySnapshot
10450 vikram.rag 630 
     - time
10050 vikram.rag 631 
    """
632 
    pass
9761 amar.kumar 633 
 
10050 vikram.rag 634 
  def getFlipkartInventorySnapshot(self, ):
635 
    pass
636 
 
10097 kshitij.so 637 
  def getFlipkartlInventoryForItem(self, item_id):
638 
    """
639 
    Parameters:
640 
     - item_id
641 
    """
642 
    pass
10050 vikram.rag 643 
 
10485 vikram.rag 644 
  def getStateMaster(self, ):
645 
    pass
10097 kshitij.so 646 
 
10544 vikram.rag 647 
  def updateSnapdealStockAtEOD(self, allsnapdealstock):
648 
    """
649 
    Parameters:
650 
     - allsnapdealstock
651 
    """
652 
    pass
10485 vikram.rag 653 
 
10544 vikram.rag 654 
  def updateFlipkartStockAtEOD(self, allflipkartstock):
655 
    """
656 
    Parameters:
657 
     - allflipkartstock
658 
    """
659 
    pass
660 
 
12363 kshitij.so 661 
  def getWanNlcForSource(self, item_id, source):
662 
    """
663 
    Parameters:
664 
     - item_id
665 
     - source
666 
    """
667 
    pass
10544 vikram.rag 668 
 
12363 kshitij.so 669 
  def getAllAvailableAmazonFbaItemInventory(self, ):
670 
    pass
671 
 
17990 kshitij.so 672 
  def updateItemAvailabilityForItemIds(self, itemIds):
673 
    """
674 
    Parameters:
675 
     - itemIds
676 
    """
677 
    pass
12363 kshitij.so 678 
 
19247 kshitij.so 679 
  def addVendorItemPricingInBulk(self, vendorItemPricingList):
680 
    """
681 
    Parameters:
682 
     - vendorItemPricingList
683 
    """
684 
    pass
17990 kshitij.so 685 
 
19247 kshitij.so 686 
  def addInventoryInBulk(self, bulkInventoryList):
687 
    """
688 
    Parameters:
689 
     - bulkInventoryList
690 
    """
691 
    pass
692 
 
22717 amit.gupta 693 
  def getFofoAvailability(self, itemIds):
694 
    """
695 
    Parameters:
696 
     - itemIds
697 
    """
698 
    pass
699 
 
22721 amit.gupta 700 
  def getFofoFulFillmentWarehouseMap(self, itemIds):
701 
    """
702 
    Parameters:
703 
     - itemIds
704 
    """
705 
    pass
706 
 
19413 amit.gupta 707 
  def getItemLocationAvailabilityCache(self, itemLocations):
708 
    """
709 
    Parameters:
710 
     - itemLocations
711 
    """
712 
    pass
19247 kshitij.so 713 
 
19413 amit.gupta 714 
  def getItemLocationAvailabilityCacheByItemId(self, itemIds):
715 
    """
716 
    Parameters:
717 
     - itemIds
718 
    """
719 
    pass
720 
 
19416 amit.gupta 721 
  def getItemPincodeAvailability(self, itempricing, pincode):
19413 amit.gupta 722 
    """
723 
    Parameters:
19416 amit.gupta 724 
     - itempricing
19413 amit.gupta 725 
     - pincode
726 
    """
727 
    pass
728 
 
729 
 
5944 mandeep.dh 730 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
731 
  def __init__(self, iprot, oprot=None):
732 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
733 
 
734 
  def addWarehouse(self, warehouse):
735 
    """
736 
    Parameters:
737 
     - warehouse
738 
    """
739 
    self.send_addWarehouse(warehouse)
740 
    return self.recv_addWarehouse()
741 
 
742 
  def send_addWarehouse(self, warehouse):
743 
    self._oprot.writeMessageBegin('addWarehouse', TMessageType.CALL, self._seqid)
744 
    args = addWarehouse_args()
745 
    args.warehouse = warehouse
746 
    args.write(self._oprot)
747 
    self._oprot.writeMessageEnd()
748 
    self._oprot.trans.flush()
749 
 
750 
  def recv_addWarehouse(self, ):
751 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
752 
    if mtype == TMessageType.EXCEPTION:
753 
      x = TApplicationException()
754 
      x.read(self._iprot)
755 
      self._iprot.readMessageEnd()
756 
      raise x
757 
    result = addWarehouse_result()
758 
    result.read(self._iprot)
759 
    self._iprot.readMessageEnd()
760 
    if result.success is not None:
761 
      return result.success
762 
    if result.cex is not None:
763 
      raise result.cex
764 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addWarehouse failed: unknown result");
765 
 
766 
  def addVendor(self, vendor):
767 
    """
768 
    add a new vendor
769 
 
770 
    Parameters:
771 
     - vendor
772 
    """
773 
    self.send_addVendor(vendor)
774 
    return self.recv_addVendor()
775 
 
776 
  def send_addVendor(self, vendor):
777 
    self._oprot.writeMessageBegin('addVendor', TMessageType.CALL, self._seqid)
778 
    args = addVendor_args()
779 
    args.vendor = vendor
780 
    args.write(self._oprot)
781 
    self._oprot.writeMessageEnd()
782 
    self._oprot.trans.flush()
783 
 
784 
  def recv_addVendor(self, ):
785 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
786 
    if mtype == TMessageType.EXCEPTION:
787 
      x = TApplicationException()
788 
      x.read(self._iprot)
789 
      self._iprot.readMessageEnd()
790 
      raise x
791 
    result = addVendor_result()
792 
    result.read(self._iprot)
793 
    self._iprot.readMessageEnd()
794 
    if result.success is not None:
795 
      return result.success
796 
    if result.cex is not None:
797 
      raise result.cex
798 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addVendor failed: unknown result");
799 
 
800 
  def updateInventoryHistory(self, warehouse_id, timestamp, availability):
801 
    """
802 
    Stores the incremental warehouse updates of items.
803 
 
804 
    Parameters:
805 
     - warehouse_id
806 
     - timestamp
807 
     - availability
808 
    """
809 
    self.send_updateInventoryHistory(warehouse_id, timestamp, availability)
810 
    self.recv_updateInventoryHistory()
811 
 
812 
  def send_updateInventoryHistory(self, warehouse_id, timestamp, availability):
813 
    self._oprot.writeMessageBegin('updateInventoryHistory', TMessageType.CALL, self._seqid)
814 
    args = updateInventoryHistory_args()
815 
    args.warehouse_id = warehouse_id
816 
    args.timestamp = timestamp
817 
    args.availability = availability
818 
    args.write(self._oprot)
819 
    self._oprot.writeMessageEnd()
820 
    self._oprot.trans.flush()
821 
 
822 
  def recv_updateInventoryHistory(self, ):
823 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
824 
    if mtype == TMessageType.EXCEPTION:
825 
      x = TApplicationException()
826 
      x.read(self._iprot)
827 
      self._iprot.readMessageEnd()
828 
      raise x
829 
    result = updateInventoryHistory_result()
830 
    result.read(self._iprot)
831 
    self._iprot.readMessageEnd()
832 
    if result.cex is not None:
833 
      raise result.cex
834 
    return
835 
 
836 
  def updateInventory(self, warehouse_id, timestamp, availability):
837 
    """
838 
    Stores the final inventory stocks of items.
839 
 
840 
    Parameters:
841 
     - warehouse_id
842 
     - timestamp
843 
     - availability
844 
    """
845 
    self.send_updateInventory(warehouse_id, timestamp, availability)
846 
    self.recv_updateInventory()
847 
 
848 
  def send_updateInventory(self, warehouse_id, timestamp, availability):
849 
    self._oprot.writeMessageBegin('updateInventory', TMessageType.CALL, self._seqid)
850 
    args = updateInventory_args()
851 
    args.warehouse_id = warehouse_id
852 
    args.timestamp = timestamp
853 
    args.availability = availability
854 
    args.write(self._oprot)
855 
    self._oprot.writeMessageEnd()
856 
    self._oprot.trans.flush()
857 
 
858 
  def recv_updateInventory(self, ):
859 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
860 
    if mtype == TMessageType.EXCEPTION:
861 
      x = TApplicationException()
862 
      x.read(self._iprot)
863 
      self._iprot.readMessageEnd()
864 
      raise x
865 
    result = updateInventory_result()
866 
    result.read(self._iprot)
867 
    self._iprot.readMessageEnd()
868 
    if result.cex is not None:
869 
      raise result.cex
870 
    return
871 
 
872 
  def addInventory(self, itemId, warehouseId, quantity):
873 
    """
874 
    Add the inventory to existing stock.
875 
 
876 
    Parameters:
877 
     - itemId
878 
     - warehouseId
879 
     - quantity
880 
    """
881 
    self.send_addInventory(itemId, warehouseId, quantity)
882 
    self.recv_addInventory()
883 
 
884 
  def send_addInventory(self, itemId, warehouseId, quantity):
885 
    self._oprot.writeMessageBegin('addInventory', TMessageType.CALL, self._seqid)
886 
    args = addInventory_args()
887 
    args.itemId = itemId
888 
    args.warehouseId = warehouseId
889 
    args.quantity = quantity
890 
    args.write(self._oprot)
891 
    self._oprot.writeMessageEnd()
892 
    self._oprot.trans.flush()
893 
 
894 
  def recv_addInventory(self, ):
895 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
896 
    if mtype == TMessageType.EXCEPTION:
897 
      x = TApplicationException()
898 
      x.read(self._iprot)
899 
      self._iprot.readMessageEnd()
900 
      raise x
901 
    result = addInventory_result()
902 
    result.read(self._iprot)
903 
    self._iprot.readMessageEnd()
904 
    if result.cex is not None:
905 
      raise result.cex
906 
    return
907 
 
908 
  def retireWarehouse(self, warehouse_id):
909 
    """
910 
    Parameters:
911 
     - warehouse_id
912 
    """
913 
    self.send_retireWarehouse(warehouse_id)
914 
    self.recv_retireWarehouse()
915 
 
916 
  def send_retireWarehouse(self, warehouse_id):
917 
    self._oprot.writeMessageBegin('retireWarehouse', TMessageType.CALL, self._seqid)
918 
    args = retireWarehouse_args()
919 
    args.warehouse_id = warehouse_id
920 
    args.write(self._oprot)
921 
    self._oprot.writeMessageEnd()
922 
    self._oprot.trans.flush()
923 
 
924 
  def recv_retireWarehouse(self, ):
925 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
926 
    if mtype == TMessageType.EXCEPTION:
927 
      x = TApplicationException()
928 
      x.read(self._iprot)
929 
      self._iprot.readMessageEnd()
930 
      raise x
931 
    result = retireWarehouse_result()
932 
    result.read(self._iprot)
933 
    self._iprot.readMessageEnd()
934 
    if result.cex is not None:
935 
      raise result.cex
936 
    return
937 
 
938 
  def getItemInventoryByItemId(self, item_id):
939 
    """
940 
    Parameters:
941 
     - item_id
942 
    """
943 
    self.send_getItemInventoryByItemId(item_id)
944 
    return self.recv_getItemInventoryByItemId()
945 
 
946 
  def send_getItemInventoryByItemId(self, item_id):
947 
    self._oprot.writeMessageBegin('getItemInventoryByItemId', TMessageType.CALL, self._seqid)
948 
    args = getItemInventoryByItemId_args()
949 
    args.item_id = item_id
950 
    args.write(self._oprot)
951 
    self._oprot.writeMessageEnd()
952 
    self._oprot.trans.flush()
953 
 
954 
  def recv_getItemInventoryByItemId(self, ):
955 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
956 
    if mtype == TMessageType.EXCEPTION:
957 
      x = TApplicationException()
958 
      x.read(self._iprot)
959 
      self._iprot.readMessageEnd()
960 
      raise x
961 
    result = getItemInventoryByItemId_result()
962 
    result.read(self._iprot)
963 
    self._iprot.readMessageEnd()
964 
    if result.success is not None:
965 
      return result.success
966 
    if result.cex is not None:
967 
      raise result.cex
968 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemInventoryByItemId failed: unknown result");
969 
 
970 
  def getItemAvailibilityAtWarehouse(self, warehouse_id, item_id):
971 
    """
972 
    Parameters:
973 
     - warehouse_id
974 
     - item_id
975 
    """
976 
    self.send_getItemAvailibilityAtWarehouse(warehouse_id, item_id)
977 
    return self.recv_getItemAvailibilityAtWarehouse()
978 
 
979 
  def send_getItemAvailibilityAtWarehouse(self, warehouse_id, item_id):
980 
    self._oprot.writeMessageBegin('getItemAvailibilityAtWarehouse', TMessageType.CALL, self._seqid)
981 
    args = getItemAvailibilityAtWarehouse_args()
982 
    args.warehouse_id = warehouse_id
983 
    args.item_id = item_id
984 
    args.write(self._oprot)
985 
    self._oprot.writeMessageEnd()
986 
    self._oprot.trans.flush()
987 
 
988 
  def recv_getItemAvailibilityAtWarehouse(self, ):
989 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
990 
    if mtype == TMessageType.EXCEPTION:
991 
      x = TApplicationException()
992 
      x.read(self._iprot)
993 
      self._iprot.readMessageEnd()
994 
      raise x
995 
    result = getItemAvailibilityAtWarehouse_result()
996 
    result.read(self._iprot)
997 
    self._iprot.readMessageEnd()
998 
    if result.success is not None:
999 
      return result.success
1000 
    if result.cex is not None:
1001 
      raise result.cex
1002 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemAvailibilityAtWarehouse failed: unknown result");
1003 
 
23446 amit.gupta 1004 
  def getItemAvailabilityAtLocation(self, itemId, sourceId, stateId):
5944 mandeep.dh 1005 
    """
1006 
    Determines the warehouse that should be used to fulfil an order for the given item.
1007 
    It first checks all the warehouses which are in the logistics location given by the
1008 
    warehouse_loc parameter. If none of the warehouses there have any inventory, then the
1009 
    preferred warehouse for the item is used.
1010 
 
1011 
    Returns an ordered list of size 4 with following elements in the given order:
1012 
    1. Id of the fulfillment warehouse which was finally picked up.
1013 
    2. Expected delay added by the category manager.
1014 
    3. Id of the billing warehouse which was finally picked up.
1015 
 
1016 
    Parameters:
1017 
     - itemId
5978 rajveer 1018 
     - sourceId
23446 amit.gupta 1019 
     - stateId
5944 mandeep.dh 1020 
    """
23446 amit.gupta 1021 
    self.send_getItemAvailabilityAtLocation(itemId, sourceId, stateId)
5944 mandeep.dh 1022 
    return self.recv_getItemAvailabilityAtLocation()
1023 
 
23446 amit.gupta 1024 
  def send_getItemAvailabilityAtLocation(self, itemId, sourceId, stateId):
5944 mandeep.dh 1025 
    self._oprot.writeMessageBegin('getItemAvailabilityAtLocation', TMessageType.CALL, self._seqid)
1026 
    args = getItemAvailabilityAtLocation_args()
1027 
    args.itemId = itemId
5978 rajveer 1028 
    args.sourceId = sourceId
23446 amit.gupta 1029 
    args.stateId = stateId
5944 mandeep.dh 1030 
    args.write(self._oprot)
1031 
    self._oprot.writeMessageEnd()
1032 
    self._oprot.trans.flush()
1033 
 
1034 
  def recv_getItemAvailabilityAtLocation(self, ):
1035 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1036 
    if mtype == TMessageType.EXCEPTION:
1037 
      x = TApplicationException()
1038 
      x.read(self._iprot)
1039 
      self._iprot.readMessageEnd()
1040 
      raise x
1041 
    result = getItemAvailabilityAtLocation_result()
1042 
    result.read(self._iprot)
1043 
    self._iprot.readMessageEnd()
1044 
    if result.success is not None:
1045 
      return result.success
1046 
    if result.isex is not None:
1047 
      raise result.isex
1048 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemAvailabilityAtLocation failed: unknown result");
1049 
 
1050 
  def getAllWarehouses(self, isActive):
1051 
    """
1052 
    Parameters:
1053 
     - isActive
1054 
    """
1055 
    self.send_getAllWarehouses(isActive)
1056 
    return self.recv_getAllWarehouses()
1057 
 
1058 
  def send_getAllWarehouses(self, isActive):
1059 
    self._oprot.writeMessageBegin('getAllWarehouses', TMessageType.CALL, self._seqid)
1060 
    args = getAllWarehouses_args()
1061 
    args.isActive = isActive
1062 
    args.write(self._oprot)
1063 
    self._oprot.writeMessageEnd()
1064 
    self._oprot.trans.flush()
1065 
 
1066 
  def recv_getAllWarehouses(self, ):
1067 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1068 
    if mtype == TMessageType.EXCEPTION:
1069 
      x = TApplicationException()
1070 
      x.read(self._iprot)
1071 
      self._iprot.readMessageEnd()
1072 
      raise x
1073 
    result = getAllWarehouses_result()
1074 
    result.read(self._iprot)
1075 
    self._iprot.readMessageEnd()
1076 
    if result.success is not None:
1077 
      return result.success
1078 
    if result.cex is not None:
1079 
      raise result.cex
1080 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllWarehouses failed: unknown result");
1081 
 
1082 
  def getWarehouse(self, warehouse_id):
1083 
    """
1084 
    Returns the warehouse with the given id.
1085 
 
1086 
    Parameters:
1087 
     - warehouse_id
1088 
    """
1089 
    self.send_getWarehouse(warehouse_id)
1090 
    return self.recv_getWarehouse()
1091 
 
1092 
  def send_getWarehouse(self, warehouse_id):
1093 
    self._oprot.writeMessageBegin('getWarehouse', TMessageType.CALL, self._seqid)
1094 
    args = getWarehouse_args()
1095 
    args.warehouse_id = warehouse_id
1096 
    args.write(self._oprot)
1097 
    self._oprot.writeMessageEnd()
1098 
    self._oprot.trans.flush()
1099 
 
1100 
  def recv_getWarehouse(self, ):
1101 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1102 
    if mtype == TMessageType.EXCEPTION:
1103 
      x = TApplicationException()
1104 
      x.read(self._iprot)
1105 
      self._iprot.readMessageEnd()
1106 
      raise x
1107 
    result = getWarehouse_result()
1108 
    result.read(self._iprot)
1109 
    self._iprot.readMessageEnd()
1110 
    if result.success is not None:
1111 
      return result.success
1112 
    if result.cex is not None:
1113 
      raise result.cex
1114 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getWarehouse failed: unknown result");
1115 
 
1116 
  def getAllItemsForWarehouse(self, warehouse_id):
1117 
    """
1118 
    Parameters:
1119 
     - warehouse_id
1120 
    """
1121 
    self.send_getAllItemsForWarehouse(warehouse_id)
1122 
    return self.recv_getAllItemsForWarehouse()
1123 
 
1124 
  def send_getAllItemsForWarehouse(self, warehouse_id):
1125 
    self._oprot.writeMessageBegin('getAllItemsForWarehouse', TMessageType.CALL, self._seqid)
1126 
    args = getAllItemsForWarehouse_args()
1127 
    args.warehouse_id = warehouse_id
1128 
    args.write(self._oprot)
1129 
    self._oprot.writeMessageEnd()
1130 
    self._oprot.trans.flush()
1131 
 
1132 
  def recv_getAllItemsForWarehouse(self, ):
1133 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1134 
    if mtype == TMessageType.EXCEPTION:
1135 
      x = TApplicationException()
1136 
      x.read(self._iprot)
1137 
      self._iprot.readMessageEnd()
1138 
      raise x
1139 
    result = getAllItemsForWarehouse_result()
1140 
    result.read(self._iprot)
1141 
    self._iprot.readMessageEnd()
1142 
    if result.success is not None:
1143 
      return result.success
1144 
    if result.cex is not None:
1145 
      raise result.cex
1146 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsForWarehouse failed: unknown result");
1147 
 
5966 rajveer 1148 
  def isOrderBillable(self, itemId, warehouseId, sourceId, orderId):
5944 mandeep.dh 1149 
    """
5978 rajveer 1150 
    Depending on reservation in the table, verify if we can bill this order or not.
5966 rajveer 1151 
 
1152 
    Parameters:
1153 
     - itemId
1154 
     - warehouseId
1155 
     - sourceId
1156 
     - orderId
1157 
    """
1158 
    self.send_isOrderBillable(itemId, warehouseId, sourceId, orderId)
1159 
    return self.recv_isOrderBillable()
1160 
 
1161 
  def send_isOrderBillable(self, itemId, warehouseId, sourceId, orderId):
1162 
    self._oprot.writeMessageBegin('isOrderBillable', TMessageType.CALL, self._seqid)
1163 
    args = isOrderBillable_args()
1164 
    args.itemId = itemId
1165 
    args.warehouseId = warehouseId
1166 
    args.sourceId = sourceId
1167 
    args.orderId = orderId
1168 
    args.write(self._oprot)
1169 
    self._oprot.writeMessageEnd()
1170 
    self._oprot.trans.flush()
1171 
 
1172 
  def recv_isOrderBillable(self, ):
1173 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1174 
    if mtype == TMessageType.EXCEPTION:
1175 
      x = TApplicationException()
1176 
      x.read(self._iprot)
1177 
      self._iprot.readMessageEnd()
1178 
      raise x
1179 
    result = isOrderBillable_result()
1180 
    result.read(self._iprot)
1181 
    self._iprot.readMessageEnd()
1182 
    if result.success is not None:
1183 
      return result.success
1184 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isOrderBillable failed: unknown result");
1185 
 
1186 
  def reserveItemInWarehouse(self, itemId, warehouseId, sourceId, orderId, createdTimestamp, promisedShippingTimestamp, quantity):
1187 
    """
5944 mandeep.dh 1188 
    Increases the reservation count for an item in a warehouse. Should always succeed normally.
1189 
 
1190 
    Parameters:
1191 
     - itemId
1192 
     - warehouseId
5966 rajveer 1193 
     - sourceId
1194 
     - orderId
1195 
     - createdTimestamp
1196 
     - promisedShippingTimestamp
5944 mandeep.dh 1197 
     - quantity
1198 
    """
5966 rajveer 1199 
    self.send_reserveItemInWarehouse(itemId, warehouseId, sourceId, orderId, createdTimestamp, promisedShippingTimestamp, quantity)
5944 mandeep.dh 1200 
    return self.recv_reserveItemInWarehouse()
1201 
 
5966 rajveer 1202 
  def send_reserveItemInWarehouse(self, itemId, warehouseId, sourceId, orderId, createdTimestamp, promisedShippingTimestamp, quantity):
5944 mandeep.dh 1203 
    self._oprot.writeMessageBegin('reserveItemInWarehouse', TMessageType.CALL, self._seqid)
1204 
    args = reserveItemInWarehouse_args()
1205 
    args.itemId = itemId
1206 
    args.warehouseId = warehouseId
5966 rajveer 1207 
    args.sourceId = sourceId
1208 
    args.orderId = orderId
1209 
    args.createdTimestamp = createdTimestamp
1210 
    args.promisedShippingTimestamp = promisedShippingTimestamp
5944 mandeep.dh 1211 
    args.quantity = quantity
1212 
    args.write(self._oprot)
1213 
    self._oprot.writeMessageEnd()
1214 
    self._oprot.trans.flush()
1215 
 
1216 
  def recv_reserveItemInWarehouse(self, ):
1217 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1218 
    if mtype == TMessageType.EXCEPTION:
1219 
      x = TApplicationException()
1220 
      x.read(self._iprot)
1221 
      self._iprot.readMessageEnd()
1222 
      raise x
1223 
    result = reserveItemInWarehouse_result()
1224 
    result.read(self._iprot)
1225 
    self._iprot.readMessageEnd()
1226 
    if result.success is not None:
1227 
      return result.success
1228 
    if result.cex is not None:
1229 
      raise result.cex
1230 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reserveItemInWarehouse failed: unknown result");
1231 
 
7968 amar.kumar 1232 
  def updateReservationForOrder(self, itemId, warehouseId, sourceId, orderId, createdTimestamp, promisedShippingTimestamp, quantity):
1233 
    """
1234 
    Updates the reservation for Order
1235 
 
1236 
    Parameters:
1237 
     - itemId
1238 
     - warehouseId
1239 
     - sourceId
1240 
     - orderId
1241 
     - createdTimestamp
1242 
     - promisedShippingTimestamp
1243 
     - quantity
1244 
    """
1245 
    self.send_updateReservationForOrder(itemId, warehouseId, sourceId, orderId, createdTimestamp, promisedShippingTimestamp, quantity)
1246 
    return self.recv_updateReservationForOrder()
1247 
 
1248 
  def send_updateReservationForOrder(self, itemId, warehouseId, sourceId, orderId, createdTimestamp, promisedShippingTimestamp, quantity):
1249 
    self._oprot.writeMessageBegin('updateReservationForOrder', TMessageType.CALL, self._seqid)
1250 
    args = updateReservationForOrder_args()
1251 
    args.itemId = itemId
1252 
    args.warehouseId = warehouseId
1253 
    args.sourceId = sourceId
1254 
    args.orderId = orderId
1255 
    args.createdTimestamp = createdTimestamp
1256 
    args.promisedShippingTimestamp = promisedShippingTimestamp
1257 
    args.quantity = quantity
1258 
    args.write(self._oprot)
1259 
    self._oprot.writeMessageEnd()
1260 
    self._oprot.trans.flush()
1261 
 
1262 
  def recv_updateReservationForOrder(self, ):
1263 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1264 
    if mtype == TMessageType.EXCEPTION:
1265 
      x = TApplicationException()
1266 
      x.read(self._iprot)
1267 
      self._iprot.readMessageEnd()
1268 
      raise x
1269 
    result = updateReservationForOrder_result()
1270 
    result.read(self._iprot)
1271 
    self._iprot.readMessageEnd()
1272 
    if result.success is not None:
1273 
      return result.success
1274 
    if result.cex is not None:
1275 
      raise result.cex
1276 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateReservationForOrder failed: unknown result");
1277 
 
5966 rajveer 1278 
  def reduceReservationCount(self, itemId, warehouseId, sourceId, orderId, quantity):
5944 mandeep.dh 1279 
    """
1280 
    Decreases the reservation count for an item in a warehouse. Should always succeed normally.
1281 
 
1282 
    Parameters:
1283 
     - itemId
1284 
     - warehouseId
5966 rajveer 1285 
     - sourceId
1286 
     - orderId
5944 mandeep.dh 1287 
     - quantity
1288 
    """
5966 rajveer 1289 
    self.send_reduceReservationCount(itemId, warehouseId, sourceId, orderId, quantity)
5944 mandeep.dh 1290 
    return self.recv_reduceReservationCount()
1291 
 
5966 rajveer 1292 
  def send_reduceReservationCount(self, itemId, warehouseId, sourceId, orderId, quantity):
5944 mandeep.dh 1293 
    self._oprot.writeMessageBegin('reduceReservationCount', TMessageType.CALL, self._seqid)
1294 
    args = reduceReservationCount_args()
1295 
    args.itemId = itemId
1296 
    args.warehouseId = warehouseId
5966 rajveer 1297 
    args.sourceId = sourceId
1298 
    args.orderId = orderId
5944 mandeep.dh 1299 
    args.quantity = quantity
1300 
    args.write(self._oprot)
1301 
    self._oprot.writeMessageEnd()
1302 
    self._oprot.trans.flush()
1303 
 
1304 
  def recv_reduceReservationCount(self, ):
1305 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1306 
    if mtype == TMessageType.EXCEPTION:
1307 
      x = TApplicationException()
1308 
      x.read(self._iprot)
1309 
      self._iprot.readMessageEnd()
1310 
      raise x
1311 
    result = reduceReservationCount_result()
1312 
    result.read(self._iprot)
1313 
    self._iprot.readMessageEnd()
1314 
    if result.success is not None:
1315 
      return result.success
1316 
    if result.cex is not None:
1317 
      raise result.cex
1318 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reduceReservationCount failed: unknown result");
1319 
 
1320 
  def getItemPricing(self, itemId, vendorId):
1321 
    """
1322 
    Returns the pricing information of an item associated with the vendor of the given warehouse.
1323 
    Raises an exception if either the item, vendor or the associated pricing information can't be found.
1324 
 
1325 
    Parameters:
1326 
     - itemId
1327 
     - vendorId
1328 
    """
1329 
    self.send_getItemPricing(itemId, vendorId)
1330 
    return self.recv_getItemPricing()
1331 
 
1332 
  def send_getItemPricing(self, itemId, vendorId):
1333 
    self._oprot.writeMessageBegin('getItemPricing', TMessageType.CALL, self._seqid)
1334 
    args = getItemPricing_args()
1335 
    args.itemId = itemId
1336 
    args.vendorId = vendorId
1337 
    args.write(self._oprot)
1338 
    self._oprot.writeMessageEnd()
1339 
    self._oprot.trans.flush()
1340 
 
1341 
  def recv_getItemPricing(self, ):
1342 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1343 
    if mtype == TMessageType.EXCEPTION:
1344 
      x = TApplicationException()
1345 
      x.read(self._iprot)
1346 
      self._iprot.readMessageEnd()
1347 
      raise x
1348 
    result = getItemPricing_result()
1349 
    result.read(self._iprot)
1350 
    self._iprot.readMessageEnd()
1351 
    if result.success is not None:
1352 
      return result.success
1353 
    if result.cex is not None:
1354 
      raise result.cex
1355 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricing failed: unknown result");
1356 
 
1357 
  def getAllItemPricing(self, itemId):
1358 
    """
1359 
    Returns the list of vendor pricing information of an item.
1360 
    Raises an exception if item not found corresponding to itemId
1361 
 
1362 
    Parameters:
1363 
     - itemId
1364 
    """
1365 
    self.send_getAllItemPricing(itemId)
1366 
    return self.recv_getAllItemPricing()
1367 
 
1368 
  def send_getAllItemPricing(self, itemId):
1369 
    self._oprot.writeMessageBegin('getAllItemPricing', TMessageType.CALL, self._seqid)
1370 
    args = getAllItemPricing_args()
1371 
    args.itemId = itemId
1372 
    args.write(self._oprot)
1373 
    self._oprot.writeMessageEnd()
1374 
    self._oprot.trans.flush()
1375 
 
1376 
  def recv_getAllItemPricing(self, ):
1377 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1378 
    if mtype == TMessageType.EXCEPTION:
1379 
      x = TApplicationException()
1380 
      x.read(self._iprot)
1381 
      self._iprot.readMessageEnd()
1382 
      raise x
1383 
    result = getAllItemPricing_result()
1384 
    result.read(self._iprot)
1385 
    self._iprot.readMessageEnd()
1386 
    if result.success is not None:
1387 
      return result.success
1388 
    if result.cex is not None:
1389 
      raise result.cex
1390 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemPricing failed: unknown result");
1391 
 
1392 
  def addVendorItemPricing(self, vendorItemPricing):
1393 
    """
1394 
    Adds vendor prices corresponding to the item. If pricing already exists then updates the prices.
1395 
    Raises an exception if either the item or vendor can't be found corresponding to their ids.
1396 
 
1397 
    Parameters:
1398 
     - vendorItemPricing
1399 
    """
1400 
    self.send_addVendorItemPricing(vendorItemPricing)
1401 
    self.recv_addVendorItemPricing()
1402 
 
1403 
  def send_addVendorItemPricing(self, vendorItemPricing):
1404 
    self._oprot.writeMessageBegin('addVendorItemPricing', TMessageType.CALL, self._seqid)
1405 
    args = addVendorItemPricing_args()
1406 
    args.vendorItemPricing = vendorItemPricing
1407 
    args.write(self._oprot)
1408 
    self._oprot.writeMessageEnd()
1409 
    self._oprot.trans.flush()
1410 
 
1411 
  def recv_addVendorItemPricing(self, ):
1412 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1413 
    if mtype == TMessageType.EXCEPTION:
1414 
      x = TApplicationException()
1415 
      x.read(self._iprot)
1416 
      self._iprot.readMessageEnd()
1417 
      raise x
1418 
    result = addVendorItemPricing_result()
1419 
    result.read(self._iprot)
1420 
    self._iprot.readMessageEnd()
1421 
    if result.cex is not None:
1422 
      raise result.cex
1423 
    return
1424 
 
1425 
  def getVendor(self, vendorId):
1426 
    """
1427 
    Returns a vendor given its id
1428 
 
1429 
    Parameters:
1430 
     - vendorId
1431 
    """
1432 
    self.send_getVendor(vendorId)
1433 
    return self.recv_getVendor()
1434 
 
1435 
  def send_getVendor(self, vendorId):
1436 
    self._oprot.writeMessageBegin('getVendor', TMessageType.CALL, self._seqid)
1437 
    args = getVendor_args()
1438 
    args.vendorId = vendorId
1439 
    args.write(self._oprot)
1440 
    self._oprot.writeMessageEnd()
1441 
    self._oprot.trans.flush()
1442 
 
1443 
  def recv_getVendor(self, ):
1444 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1445 
    if mtype == TMessageType.EXCEPTION:
1446 
      x = TApplicationException()
1447 
      x.read(self._iprot)
1448 
      self._iprot.readMessageEnd()
1449 
      raise x
1450 
    result = getVendor_result()
1451 
    result.read(self._iprot)
1452 
    self._iprot.readMessageEnd()
1453 
    if result.success is not None:
1454 
      return result.success
1455 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVendor failed: unknown result");
1456 
 
1457 
  def getAllVendors(self, ):
1458 
    """
1459 
    Return list of all vendors
1460 
    """
1461 
    self.send_getAllVendors()
1462 
    return self.recv_getAllVendors()
1463 
 
1464 
  def send_getAllVendors(self, ):
1465 
    self._oprot.writeMessageBegin('getAllVendors', TMessageType.CALL, self._seqid)
1466 
    args = getAllVendors_args()
1467 
    args.write(self._oprot)
1468 
    self._oprot.writeMessageEnd()
1469 
    self._oprot.trans.flush()
1470 
 
1471 
  def recv_getAllVendors(self, ):
1472 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1473 
    if mtype == TMessageType.EXCEPTION:
1474 
      x = TApplicationException()
1475 
      x.read(self._iprot)
1476 
      self._iprot.readMessageEnd()
1477 
      raise x
1478 
    result = getAllVendors_result()
1479 
    result.read(self._iprot)
1480 
    self._iprot.readMessageEnd()
1481 
    if result.success is not None:
1482 
      return result.success
1483 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVendors failed: unknown result");
1484 
 
1485 
  def addVendorItemMapping(self, key, vendorItemMapping):
1486 
    """
1487 
    Adds VendorItemMapping. Updates VendorItemMapping if exists corresponding to the item key.
1488 
 
1489 
    Parameters:
1490 
     - key
1491 
     - vendorItemMapping
1492 
    """
1493 
    self.send_addVendorItemMapping(key, vendorItemMapping)
1494 
    self.recv_addVendorItemMapping()
1495 
 
1496 
  def send_addVendorItemMapping(self, key, vendorItemMapping):
1497 
    self._oprot.writeMessageBegin('addVendorItemMapping', TMessageType.CALL, self._seqid)
1498 
    args = addVendorItemMapping_args()
1499 
    args.key = key
1500 
    args.vendorItemMapping = vendorItemMapping
1501 
    args.write(self._oprot)
1502 
    self._oprot.writeMessageEnd()
1503 
    self._oprot.trans.flush()
1504 
 
1505 
  def recv_addVendorItemMapping(self, ):
1506 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1507 
    if mtype == TMessageType.EXCEPTION:
1508 
      x = TApplicationException()
1509 
      x.read(self._iprot)
1510 
      self._iprot.readMessageEnd()
1511 
      raise x
1512 
    result = addVendorItemMapping_result()
1513 
    result.read(self._iprot)
1514 
    self._iprot.readMessageEnd()
1515 
    if result.cex is not None:
1516 
      raise result.cex
1517 
    return
1518 
 
1519 
  def getVendorItemMappings(self, itemId):
1520 
    """
1521 
    Returns the list of vendor item mapping corresponding to itemId passed as parameter.
1522 
    Raises an exception if item not found corresponding to itemId
1523 
 
1524 
    Parameters:
1525 
     - itemId
1526 
    """
1527 
    self.send_getVendorItemMappings(itemId)
1528 
    return self.recv_getVendorItemMappings()
1529 
 
1530 
  def send_getVendorItemMappings(self, itemId):
1531 
    self._oprot.writeMessageBegin('getVendorItemMappings', TMessageType.CALL, self._seqid)
1532 
    args = getVendorItemMappings_args()
1533 
    args.itemId = itemId
1534 
    args.write(self._oprot)
1535 
    self._oprot.writeMessageEnd()
1536 
    self._oprot.trans.flush()
1537 
 
1538 
  def recv_getVendorItemMappings(self, ):
1539 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1540 
    if mtype == TMessageType.EXCEPTION:
1541 
      x = TApplicationException()
1542 
      x.read(self._iprot)
1543 
      self._iprot.readMessageEnd()
1544 
      raise x
1545 
    result = getVendorItemMappings_result()
1546 
    result.read(self._iprot)
1547 
    self._iprot.readMessageEnd()
1548 
    if result.success is not None:
1549 
      return result.success
1550 
    if result.cex is not None:
1551 
      raise result.cex
1552 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVendorItemMappings failed: unknown result");
1553 
 
1554 
  def getPendingOrdersInventory(self, vendorid):
1555 
    """
1556 
    Returns a list of inventory stock for items for which there are pending orders for the given vendor.
1557 
 
1558 
    Parameters:
1559 
     - vendorid
1560 
    """
1561 
    self.send_getPendingOrdersInventory(vendorid)
1562 
    return self.recv_getPendingOrdersInventory()
1563 
 
1564 
  def send_getPendingOrdersInventory(self, vendorid):
1565 
    self._oprot.writeMessageBegin('getPendingOrdersInventory', TMessageType.CALL, self._seqid)
1566 
    args = getPendingOrdersInventory_args()
1567 
    args.vendorid = vendorid
1568 
    args.write(self._oprot)
1569 
    self._oprot.writeMessageEnd()
1570 
    self._oprot.trans.flush()
1571 
 
1572 
  def recv_getPendingOrdersInventory(self, ):
1573 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1574 
    if mtype == TMessageType.EXCEPTION:
1575 
      x = TApplicationException()
1576 
      x.read(self._iprot)
1577 
      self._iprot.readMessageEnd()
1578 
      raise x
1579 
    result = getPendingOrdersInventory_result()
1580 
    result.read(self._iprot)
1581 
    self._iprot.readMessageEnd()
1582 
    if result.success is not None:
1583 
      return result.success
1584 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPendingOrdersInventory failed: unknown result");
1585 
 
1586 
  def getWarehouses(self, warehouseType, inventoryType, vendorId, billingWarehouseId, shippingWarehouseId):
1587 
    """
1588 
    This method returns all warehouses for a given warehosueType, inventoryType, vendor, billingWarehouse and shippingWarehouse.
1589 
    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
1590 
    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
1591 
       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
1592 
       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
1593 
 
1594 
    Parameters:
1595 
     - warehouseType
1596 
     - inventoryType
1597 
     - vendorId
1598 
     - billingWarehouseId
1599 
     - shippingWarehouseId
1600 
    """
1601 
    self.send_getWarehouses(warehouseType, inventoryType, vendorId, billingWarehouseId, shippingWarehouseId)
1602 
    return self.recv_getWarehouses()
1603 
 
1604 
  def send_getWarehouses(self, warehouseType, inventoryType, vendorId, billingWarehouseId, shippingWarehouseId):
1605 
    self._oprot.writeMessageBegin('getWarehouses', TMessageType.CALL, self._seqid)
1606 
    args = getWarehouses_args()
1607 
    args.warehouseType = warehouseType
1608 
    args.inventoryType = inventoryType
1609 
    args.vendorId = vendorId
1610 
    args.billingWarehouseId = billingWarehouseId
1611 
    args.shippingWarehouseId = shippingWarehouseId
1612 
    args.write(self._oprot)
1613 
    self._oprot.writeMessageEnd()
1614 
    self._oprot.trans.flush()
1615 
 
1616 
  def recv_getWarehouses(self, ):
1617 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1618 
    if mtype == TMessageType.EXCEPTION:
1619 
      x = TApplicationException()
1620 
      x.read(self._iprot)
1621 
      self._iprot.readMessageEnd()
1622 
      raise x
1623 
    result = getWarehouses_result()
1624 
    result.read(self._iprot)
1625 
    self._iprot.readMessageEnd()
1626 
    if result.success is not None:
1627 
      return result.success
1628 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getWarehouses failed: unknown result");
1629 
 
1630 
  def resetAvailability(self, itemKey, vendorId, quantity, warehouseId):
1631 
    """
1632 
    Resets availability of an item to the quantity mentioned in a warehouse.
1633 
 
1634 
    Parameters:
1635 
     - itemKey
1636 
     - vendorId
1637 
     - quantity
1638 
     - warehouseId
1639 
    """
1640 
    self.send_resetAvailability(itemKey, vendorId, quantity, warehouseId)
1641 
    self.recv_resetAvailability()
1642 
 
1643 
  def send_resetAvailability(self, itemKey, vendorId, quantity, warehouseId):
1644 
    self._oprot.writeMessageBegin('resetAvailability', TMessageType.CALL, self._seqid)
1645 
    args = resetAvailability_args()
1646 
    args.itemKey = itemKey
1647 
    args.vendorId = vendorId
1648 
    args.quantity = quantity
1649 
    args.warehouseId = warehouseId
1650 
    args.write(self._oprot)
1651 
    self._oprot.writeMessageEnd()
1652 
    self._oprot.trans.flush()
1653 
 
1654 
  def recv_resetAvailability(self, ):
1655 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1656 
    if mtype == TMessageType.EXCEPTION:
1657 
      x = TApplicationException()
1658 
      x.read(self._iprot)
1659 
      self._iprot.readMessageEnd()
1660 
      raise x
1661 
    result = resetAvailability_result()
1662 
    result.read(self._iprot)
1663 
    self._iprot.readMessageEnd()
1664 
    if result.cex is not None:
1665 
      raise result.cex
1666 
    return
1667 
 
1668 
  def resetAvailabilityForWarehouse(self, warehouseId):
1669 
    """
1670 
    Resets availability of a warehouse to zero.
1671 
 
1672 
    Parameters:
1673 
     - warehouseId
1674 
    """
1675 
    self.send_resetAvailabilityForWarehouse(warehouseId)
1676 
    self.recv_resetAvailabilityForWarehouse()
1677 
 
1678 
  def send_resetAvailabilityForWarehouse(self, warehouseId):
1679 
    self._oprot.writeMessageBegin('resetAvailabilityForWarehouse', TMessageType.CALL, self._seqid)
1680 
    args = resetAvailabilityForWarehouse_args()
1681 
    args.warehouseId = warehouseId
1682 
    args.write(self._oprot)
1683 
    self._oprot.writeMessageEnd()
1684 
    self._oprot.trans.flush()
1685 
 
1686 
  def recv_resetAvailabilityForWarehouse(self, ):
1687 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1688 
    if mtype == TMessageType.EXCEPTION:
1689 
      x = TApplicationException()
1690 
      x.read(self._iprot)
1691 
      self._iprot.readMessageEnd()
1692 
      raise x
1693 
    result = resetAvailabilityForWarehouse_result()
1694 
    result.read(self._iprot)
1695 
    self._iprot.readMessageEnd()
1696 
    if result.cex is not None:
1697 
      raise result.cex
1698 
    return
1699 
 
1700 
  def getItemKeysToBeProcessed(self, warehouseId):
1701 
    """
1702 
    Returns the list of item keys which need to be processed for a given warehouse.
1703 
    This is currently used by Support application to send item keys whose inventory needs
1704 
    to be updated from PLB
1705 
 
1706 
    Parameters:
1707 
     - warehouseId
1708 
    """
1709 
    self.send_getItemKeysToBeProcessed(warehouseId)
1710 
    return self.recv_getItemKeysToBeProcessed()
1711 
 
1712 
  def send_getItemKeysToBeProcessed(self, warehouseId):
1713 
    self._oprot.writeMessageBegin('getItemKeysToBeProcessed', TMessageType.CALL, self._seqid)
1714 
    args = getItemKeysToBeProcessed_args()
1715 
    args.warehouseId = warehouseId
1716 
    args.write(self._oprot)
1717 
    self._oprot.writeMessageEnd()
1718 
    self._oprot.trans.flush()
1719 
 
1720 
  def recv_getItemKeysToBeProcessed(self, ):
1721 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1722 
    if mtype == TMessageType.EXCEPTION:
1723 
      x = TApplicationException()
1724 
      x.read(self._iprot)
1725 
      self._iprot.readMessageEnd()
1726 
      raise x
1727 
    result = getItemKeysToBeProcessed_result()
1728 
    result.read(self._iprot)
1729 
    self._iprot.readMessageEnd()
1730 
    if result.success is not None:
1731 
      return result.success
1732 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemKeysToBeProcessed failed: unknown result");
1733 
 
1734 
  def markMissedInventoryUpdatesAsProcessed(self, itemKey, warehouseId):
1735 
    """
1736 
    Marks/Deletes missed inventory updates for a given key and warehouse.
1737 
    This generally happens when updates from PLB are applied on the currentinventorysnapshot for an item
1738 
 
1739 
    Parameters:
1740 
     - itemKey
1741 
     - warehouseId
1742 
    """
1743 
    self.send_markMissedInventoryUpdatesAsProcessed(itemKey, warehouseId)
1744 
    self.recv_markMissedInventoryUpdatesAsProcessed()
1745 
 
1746 
  def send_markMissedInventoryUpdatesAsProcessed(self, itemKey, warehouseId):
1747 
    self._oprot.writeMessageBegin('markMissedInventoryUpdatesAsProcessed', TMessageType.CALL, self._seqid)
1748 
    args = markMissedInventoryUpdatesAsProcessed_args()
1749 
    args.itemKey = itemKey
1750 
    args.warehouseId = warehouseId
1751 
    args.write(self._oprot)
1752 
    self._oprot.writeMessageEnd()
1753 
    self._oprot.trans.flush()
1754 
 
1755 
  def recv_markMissedInventoryUpdatesAsProcessed(self, ):
1756 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1757 
    if mtype == TMessageType.EXCEPTION:
1758 
      x = TApplicationException()
1759 
      x.read(self._iprot)
1760 
      self._iprot.readMessageEnd()
1761 
      raise x
1762 
    result = markMissedInventoryUpdatesAsProcessed_result()
1763 
    result.read(self._iprot)
1764 
    self._iprot.readMessageEnd()
1765 
    return
1766 
 
1767 
  def getIgnoredItemKeys(self, ):
1768 
    """
1769 
    Returns all the item key mappings that have been ignored until date. Value of map has the warehouse id
1770 
    and the timestamp from where alert was raised.
1771 
    """
1772 
    self.send_getIgnoredItemKeys()
1773 
    return self.recv_getIgnoredItemKeys()
1774 
 
1775 
  def send_getIgnoredItemKeys(self, ):
1776 
    self._oprot.writeMessageBegin('getIgnoredItemKeys', TMessageType.CALL, self._seqid)
1777 
    args = getIgnoredItemKeys_args()
1778 
    args.write(self._oprot)
1779 
    self._oprot.writeMessageEnd()
1780 
    self._oprot.trans.flush()
1781 
 
1782 
  def recv_getIgnoredItemKeys(self, ):
1783 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1784 
    if mtype == TMessageType.EXCEPTION:
1785 
      x = TApplicationException()
1786 
      x.read(self._iprot)
1787 
      self._iprot.readMessageEnd()
1788 
      raise x
1789 
    result = getIgnoredItemKeys_result()
1790 
    result.read(self._iprot)
1791 
    self._iprot.readMessageEnd()
1792 
    if result.success is not None:
1793 
      return result.success
1794 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getIgnoredItemKeys failed: unknown result");
1795 
 
1796 
  def addBadInventory(self, itemId, warehouseId, quantity):
1797 
    """
1798 
    Add the BAD type inventory to existing stock.
1799 
 
1800 
    Parameters:
1801 
     - itemId
1802 
     - warehouseId
1803 
     - quantity
1804 
    """
1805 
    self.send_addBadInventory(itemId, warehouseId, quantity)
1806 
    self.recv_addBadInventory()
1807 
 
1808 
  def send_addBadInventory(self, itemId, warehouseId, quantity):
1809 
    self._oprot.writeMessageBegin('addBadInventory', TMessageType.CALL, self._seqid)
1810 
    args = addBadInventory_args()
1811 
    args.itemId = itemId
1812 
    args.warehouseId = warehouseId
1813 
    args.quantity = quantity
1814 
    args.write(self._oprot)
1815 
    self._oprot.writeMessageEnd()
1816 
    self._oprot.trans.flush()
1817 
 
1818 
  def recv_addBadInventory(self, ):
1819 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1820 
    if mtype == TMessageType.EXCEPTION:
1821 
      x = TApplicationException()
1822 
      x.read(self._iprot)
1823 
      self._iprot.readMessageEnd()
1824 
      raise x
1825 
    result = addBadInventory_result()
1826 
    result.read(self._iprot)
1827 
    self._iprot.readMessageEnd()
1828 
    if result.cex is not None:
1829 
      raise result.cex
1830 
    return
1831 
 
1832 
  def getShippingLocations(self, ):
1833 
    """
1834 
    Returns all shipping locations
1835 
    """
1836 
    self.send_getShippingLocations()
1837 
    return self.recv_getShippingLocations()
1838 
 
1839 
  def send_getShippingLocations(self, ):
1840 
    self._oprot.writeMessageBegin('getShippingLocations', TMessageType.CALL, self._seqid)
1841 
    args = getShippingLocations_args()
1842 
    args.write(self._oprot)
1843 
    self._oprot.writeMessageEnd()
1844 
    self._oprot.trans.flush()
1845 
 
1846 
  def recv_getShippingLocations(self, ):
1847 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1848 
    if mtype == TMessageType.EXCEPTION:
1849 
      x = TApplicationException()
1850 
      x.read(self._iprot)
1851 
      self._iprot.readMessageEnd()
1852 
      raise x
1853 
    result = getShippingLocations_result()
1854 
    result.read(self._iprot)
1855 
    self._iprot.readMessageEnd()
1856 
    if result.success is not None:
1857 
      return result.success
1858 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getShippingLocations failed: unknown result");
1859 
 
1860 
  def getAllVendorItemMappings(self, ):
1861 
    """
1862 
    Fetches all the vendor item mappings present.
1863 
    """
1864 
    self.send_getAllVendorItemMappings()
1865 
    return self.recv_getAllVendorItemMappings()
1866 
 
1867 
  def send_getAllVendorItemMappings(self, ):
1868 
    self._oprot.writeMessageBegin('getAllVendorItemMappings', TMessageType.CALL, self._seqid)
1869 
    args = getAllVendorItemMappings_args()
1870 
    args.write(self._oprot)
1871 
    self._oprot.writeMessageEnd()
1872 
    self._oprot.trans.flush()
1873 
 
1874 
  def recv_getAllVendorItemMappings(self, ):
1875 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1876 
    if mtype == TMessageType.EXCEPTION:
1877 
      x = TApplicationException()
1878 
      x.read(self._iprot)
1879 
      self._iprot.readMessageEnd()
1880 
      raise x
1881 
    result = getAllVendorItemMappings_result()
1882 
    result.read(self._iprot)
1883 
    self._iprot.readMessageEnd()
1884 
    if result.success is not None:
1885 
      return result.success
1886 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVendorItemMappings failed: unknown result");
1887 
 
1888 
  def getInventorySnapshot(self, warehouseId):
1889 
    """
1890 
    Gets items' inventory for a warehouse
1891 
    If warehouse is passed as zero, items' inventory across all warehouses is sent
1892 
 
1893 
    Parameters:
1894 
     - warehouseId
1895 
    """
1896 
    self.send_getInventorySnapshot(warehouseId)
1897 
    return self.recv_getInventorySnapshot()
1898 
 
1899 
  def send_getInventorySnapshot(self, warehouseId):
1900 
    self._oprot.writeMessageBegin('getInventorySnapshot', TMessageType.CALL, self._seqid)
1901 
    args = getInventorySnapshot_args()
1902 
    args.warehouseId = warehouseId
1903 
    args.write(self._oprot)
1904 
    self._oprot.writeMessageEnd()
1905 
    self._oprot.trans.flush()
1906 
 
1907 
  def recv_getInventorySnapshot(self, ):
1908 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1909 
    if mtype == TMessageType.EXCEPTION:
1910 
      x = TApplicationException()
1911 
      x.read(self._iprot)
1912 
      self._iprot.readMessageEnd()
1913 
      raise x
1914 
    result = getInventorySnapshot_result()
1915 
    result.read(self._iprot)
1916 
    self._iprot.readMessageEnd()
1917 
    if result.success is not None:
1918 
      return result.success
1919 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventorySnapshot failed: unknown result");
1920 
 
1921 
  def clearItemAvailabilityCache(self, ):
1922 
    """
1923 
    Clear item availability cache.
1924 
    """
1925 
    self.send_clearItemAvailabilityCache()
1926 
    self.recv_clearItemAvailabilityCache()
1927 
 
1928 
  def send_clearItemAvailabilityCache(self, ):
1929 
    self._oprot.writeMessageBegin('clearItemAvailabilityCache', TMessageType.CALL, self._seqid)
1930 
    args = clearItemAvailabilityCache_args()
1931 
    args.write(self._oprot)
1932 
    self._oprot.writeMessageEnd()
1933 
    self._oprot.trans.flush()
1934 
 
1935 
  def recv_clearItemAvailabilityCache(self, ):
1936 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1937 
    if mtype == TMessageType.EXCEPTION:
1938 
      x = TApplicationException()
1939 
      x.read(self._iprot)
1940 
      self._iprot.readMessageEnd()
1941 
      raise x
1942 
    result = clearItemAvailabilityCache_result()
1943 
    result.read(self._iprot)
1944 
    self._iprot.readMessageEnd()
1945 
    return
1946 
 
1947 
  def updateVendorString(self, warehouseId, vendorString):
1948 
    """
1949 
    Parameters:
1950 
     - warehouseId
1951 
     - vendorString
1952 
    """
1953 
    self.send_updateVendorString(warehouseId, vendorString)
1954 
    self.recv_updateVendorString()
1955 
 
1956 
  def send_updateVendorString(self, warehouseId, vendorString):
1957 
    self._oprot.writeMessageBegin('updateVendorString', TMessageType.CALL, self._seqid)
1958 
    args = updateVendorString_args()
1959 
    args.warehouseId = warehouseId
1960 
    args.vendorString = vendorString
1961 
    args.write(self._oprot)
1962 
    self._oprot.writeMessageEnd()
1963 
    self._oprot.trans.flush()
1964 
 
1965 
  def recv_updateVendorString(self, ):
1966 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1967 
    if mtype == TMessageType.EXCEPTION:
1968 
      x = TApplicationException()
1969 
      x.read(self._iprot)
1970 
      self._iprot.readMessageEnd()
1971 
      raise x
1972 
    result = updateVendorString_result()
1973 
    result.read(self._iprot)
1974 
    self._iprot.readMessageEnd()
1975 
    return
1976 
 
6096 amit.gupta 1977 
  def clearItemAvailabilityCacheForItem(self, item_id):
1978 
    """
1979 
    Parameters:
1980 
     - item_id
1981 
    """
1982 
    self.send_clearItemAvailabilityCacheForItem(item_id)
1983 
    self.recv_clearItemAvailabilityCacheForItem()
5944 mandeep.dh 1984 
 
6096 amit.gupta 1985 
  def send_clearItemAvailabilityCacheForItem(self, item_id):
1986 
    self._oprot.writeMessageBegin('clearItemAvailabilityCacheForItem', TMessageType.CALL, self._seqid)
1987 
    args = clearItemAvailabilityCacheForItem_args()
1988 
    args.item_id = item_id
1989 
    args.write(self._oprot)
1990 
    self._oprot.writeMessageEnd()
1991 
    self._oprot.trans.flush()
1992 
 
1993 
  def recv_clearItemAvailabilityCacheForItem(self, ):
1994 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1995 
    if mtype == TMessageType.EXCEPTION:
1996 
      x = TApplicationException()
1997 
      x.read(self._iprot)
1998 
      self._iprot.readMessageEnd()
1999 
      raise x
2000 
    result = clearItemAvailabilityCacheForItem_result()
2001 
    result.read(self._iprot)
2002 
    self._iprot.readMessageEnd()
2003 
    return
2004 
 
7718 amar.kumar 2005 
  def getOurWarehouseIdForVendor(self, vendorId, billingWarehouseId):
6467 amar.kumar 2006 
    """
2007 
    Parameters:
2008 
     - vendorId
7718 amar.kumar 2009 
     - billingWarehouseId
6467 amar.kumar 2010 
    """
7718 amar.kumar 2011 
    self.send_getOurWarehouseIdForVendor(vendorId, billingWarehouseId)
6467 amar.kumar 2012 
    return self.recv_getOurWarehouseIdForVendor()
6096 amit.gupta 2013 
 
7718 amar.kumar 2014 
  def send_getOurWarehouseIdForVendor(self, vendorId, billingWarehouseId):
6467 amar.kumar 2015 
    self._oprot.writeMessageBegin('getOurWarehouseIdForVendor', TMessageType.CALL, self._seqid)
2016 
    args = getOurWarehouseIdForVendor_args()
2017 
    args.vendorId = vendorId
7718 amar.kumar 2018 
    args.billingWarehouseId = billingWarehouseId
6467 amar.kumar 2019 
    args.write(self._oprot)
2020 
    self._oprot.writeMessageEnd()
2021 
    self._oprot.trans.flush()
2022 
 
2023 
  def recv_getOurWarehouseIdForVendor(self, ):
2024 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2025 
    if mtype == TMessageType.EXCEPTION:
2026 
      x = TApplicationException()
2027 
      x.read(self._iprot)
2028 
      self._iprot.readMessageEnd()
2029 
      raise x
2030 
    result = getOurWarehouseIdForVendor_result()
2031 
    result.read(self._iprot)
2032 
    self._iprot.readMessageEnd()
2033 
    if result.success is not None:
2034 
      return result.success
2035 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOurWarehouseIdForVendor failed: unknown result");
2036 
 
6484 amar.kumar 2037 
  def getItemAvailabilitiesAtOurWarehouses(self, item_ids):
2038 
    """
2039 
    Parameters:
2040 
     - item_ids
2041 
    """
2042 
    self.send_getItemAvailabilitiesAtOurWarehouses(item_ids)
2043 
    return self.recv_getItemAvailabilitiesAtOurWarehouses()
6467 amar.kumar 2044 
 
6484 amar.kumar 2045 
  def send_getItemAvailabilitiesAtOurWarehouses(self, item_ids):
2046 
    self._oprot.writeMessageBegin('getItemAvailabilitiesAtOurWarehouses', TMessageType.CALL, self._seqid)
2047 
    args = getItemAvailabilitiesAtOurWarehouses_args()
2048 
    args.item_ids = item_ids
2049 
    args.write(self._oprot)
2050 
    self._oprot.writeMessageEnd()
2051 
    self._oprot.trans.flush()
2052 
 
2053 
  def recv_getItemAvailabilitiesAtOurWarehouses(self, ):
2054 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2055 
    if mtype == TMessageType.EXCEPTION:
2056 
      x = TApplicationException()
2057 
      x.read(self._iprot)
2058 
      self._iprot.readMessageEnd()
2059 
      raise x
2060 
    result = getItemAvailabilitiesAtOurWarehouses_result()
2061 
    result.read(self._iprot)
2062 
    self._iprot.readMessageEnd()
2063 
    if result.success is not None:
2064 
      return result.success
2065 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemAvailabilitiesAtOurWarehouses failed: unknown result");
2066 
 
6531 vikram.rag 2067 
  def getMonitoredWarehouseForVendors(self, vendorIds):
2068 
    """
2069 
    Parameters:
2070 
     - vendorIds
2071 
    """
2072 
    self.send_getMonitoredWarehouseForVendors(vendorIds)
2073 
    return self.recv_getMonitoredWarehouseForVendors()
6484 amar.kumar 2074 
 
6531 vikram.rag 2075 
  def send_getMonitoredWarehouseForVendors(self, vendorIds):
2076 
    self._oprot.writeMessageBegin('getMonitoredWarehouseForVendors', TMessageType.CALL, self._seqid)
2077 
    args = getMonitoredWarehouseForVendors_args()
2078 
    args.vendorIds = vendorIds
2079 
    args.write(self._oprot)
2080 
    self._oprot.writeMessageEnd()
2081 
    self._oprot.trans.flush()
2082 
 
2083 
  def recv_getMonitoredWarehouseForVendors(self, ):
2084 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2085 
    if mtype == TMessageType.EXCEPTION:
2086 
      x = TApplicationException()
2087 
      x.read(self._iprot)
2088 
      self._iprot.readMessageEnd()
2089 
      raise x
2090 
    result = getMonitoredWarehouseForVendors_result()
2091 
    result.read(self._iprot)
2092 
    self._iprot.readMessageEnd()
2093 
    if result.success is not None:
2094 
      return result.success
2095 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMonitoredWarehouseForVendors failed: unknown result");
2096 
 
2097 
  def getIgnoredWarehouseidsAndItemids(self, ):
2098 
    self.send_getIgnoredWarehouseidsAndItemids()
2099 
    return self.recv_getIgnoredWarehouseidsAndItemids()
2100 
 
2101 
  def send_getIgnoredWarehouseidsAndItemids(self, ):
2102 
    self._oprot.writeMessageBegin('getIgnoredWarehouseidsAndItemids', TMessageType.CALL, self._seqid)
2103 
    args = getIgnoredWarehouseidsAndItemids_args()
2104 
    args.write(self._oprot)
2105 
    self._oprot.writeMessageEnd()
2106 
    self._oprot.trans.flush()
2107 
 
2108 
  def recv_getIgnoredWarehouseidsAndItemids(self, ):
2109 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2110 
    if mtype == TMessageType.EXCEPTION:
2111 
      x = TApplicationException()
2112 
      x.read(self._iprot)
2113 
      self._iprot.readMessageEnd()
2114 
      raise x
2115 
    result = getIgnoredWarehouseidsAndItemids_result()
2116 
    result.read(self._iprot)
2117 
    self._iprot.readMessageEnd()
2118 
    if result.success is not None:
2119 
      return result.success
2120 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getIgnoredWarehouseidsAndItemids failed: unknown result");
2121 
 
2122 
  def insertItemtoIgnoreInventoryUpdatelist(self, item_id, warehouse_id):
2123 
    """
2124 
    Parameters:
2125 
     - item_id
2126 
     - warehouse_id
2127 
    """
2128 
    self.send_insertItemtoIgnoreInventoryUpdatelist(item_id, warehouse_id)
2129 
    return self.recv_insertItemtoIgnoreInventoryUpdatelist()
2130 
 
2131 
  def send_insertItemtoIgnoreInventoryUpdatelist(self, item_id, warehouse_id):
2132 
    self._oprot.writeMessageBegin('insertItemtoIgnoreInventoryUpdatelist', TMessageType.CALL, self._seqid)
2133 
    args = insertItemtoIgnoreInventoryUpdatelist_args()
2134 
    args.item_id = item_id
2135 
    args.warehouse_id = warehouse_id
2136 
    args.write(self._oprot)
2137 
    self._oprot.writeMessageEnd()
2138 
    self._oprot.trans.flush()
2139 
 
2140 
  def recv_insertItemtoIgnoreInventoryUpdatelist(self, ):
2141 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2142 
    if mtype == TMessageType.EXCEPTION:
2143 
      x = TApplicationException()
2144 
      x.read(self._iprot)
2145 
      self._iprot.readMessageEnd()
2146 
      raise x
2147 
    result = insertItemtoIgnoreInventoryUpdatelist_result()
2148 
    result.read(self._iprot)
2149 
    self._iprot.readMessageEnd()
2150 
    if result.success is not None:
2151 
      return result.success
2152 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "insertItemtoIgnoreInventoryUpdatelist failed: unknown result");
2153 
 
2154 
  def deleteItemFromIgnoredInventoryUpdateList(self, item_id, warehouse_id):
2155 
    """
2156 
    Parameters:
2157 
     - item_id
2158 
     - warehouse_id
2159 
    """
2160 
    self.send_deleteItemFromIgnoredInventoryUpdateList(item_id, warehouse_id)
2161 
    return self.recv_deleteItemFromIgnoredInventoryUpdateList()
2162 
 
2163 
  def send_deleteItemFromIgnoredInventoryUpdateList(self, item_id, warehouse_id):
2164 
    self._oprot.writeMessageBegin('deleteItemFromIgnoredInventoryUpdateList', TMessageType.CALL, self._seqid)
2165 
    args = deleteItemFromIgnoredInventoryUpdateList_args()
2166 
    args.item_id = item_id
2167 
    args.warehouse_id = warehouse_id
2168 
    args.write(self._oprot)
2169 
    self._oprot.writeMessageEnd()
2170 
    self._oprot.trans.flush()
2171 
 
2172 
  def recv_deleteItemFromIgnoredInventoryUpdateList(self, ):
2173 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2174 
    if mtype == TMessageType.EXCEPTION:
2175 
      x = TApplicationException()
2176 
      x.read(self._iprot)
2177 
      self._iprot.readMessageEnd()
2178 
      raise x
2179 
    result = deleteItemFromIgnoredInventoryUpdateList_result()
2180 
    result.read(self._iprot)
2181 
    self._iprot.readMessageEnd()
2182 
    if result.success is not None:
2183 
      return result.success
2184 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteItemFromIgnoredInventoryUpdateList failed: unknown result");
2185 
 
2186 
  def getAllIgnoredInventoryupdateItemsCount(self, ):
2187 
    self.send_getAllIgnoredInventoryupdateItemsCount()
2188 
    return self.recv_getAllIgnoredInventoryupdateItemsCount()
2189 
 
2190 
  def send_getAllIgnoredInventoryupdateItemsCount(self, ):
2191 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryupdateItemsCount', TMessageType.CALL, self._seqid)
2192 
    args = getAllIgnoredInventoryupdateItemsCount_args()
2193 
    args.write(self._oprot)
2194 
    self._oprot.writeMessageEnd()
2195 
    self._oprot.trans.flush()
2196 
 
2197 
  def recv_getAllIgnoredInventoryupdateItemsCount(self, ):
2198 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2199 
    if mtype == TMessageType.EXCEPTION:
2200 
      x = TApplicationException()
2201 
      x.read(self._iprot)
2202 
      self._iprot.readMessageEnd()
2203 
      raise x
2204 
    result = getAllIgnoredInventoryupdateItemsCount_result()
2205 
    result.read(self._iprot)
2206 
    self._iprot.readMessageEnd()
2207 
    if result.success is not None:
2208 
      return result.success
2209 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryupdateItemsCount failed: unknown result");
2210 
 
2211 
  def getIgnoredInventoryUpdateItemids(self, offset, limit):
2212 
    """
2213 
    Parameters:
2214 
     - offset
2215 
     - limit
2216 
    """
2217 
    self.send_getIgnoredInventoryUpdateItemids(offset, limit)
2218 
    return self.recv_getIgnoredInventoryUpdateItemids()
2219 
 
2220 
  def send_getIgnoredInventoryUpdateItemids(self, offset, limit):
2221 
    self._oprot.writeMessageBegin('getIgnoredInventoryUpdateItemids', TMessageType.CALL, self._seqid)
2222 
    args = getIgnoredInventoryUpdateItemids_args()
2223 
    args.offset = offset
2224 
    args.limit = limit
2225 
    args.write(self._oprot)
2226 
    self._oprot.writeMessageEnd()
2227 
    self._oprot.trans.flush()
2228 
 
2229 
  def recv_getIgnoredInventoryUpdateItemids(self, ):
2230 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2231 
    if mtype == TMessageType.EXCEPTION:
2232 
      x = TApplicationException()
2233 
      x.read(self._iprot)
2234 
      self._iprot.readMessageEnd()
2235 
      raise x
2236 
    result = getIgnoredInventoryUpdateItemids_result()
2237 
    result.read(self._iprot)
2238 
    self._iprot.readMessageEnd()
2239 
    if result.success is not None:
2240 
      return result.success
2241 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getIgnoredInventoryUpdateItemids failed: unknown result");
2242 
 
6821 amar.kumar 2243 
  def updateItemStockPurchaseParams(self, item_id, numOfDaysStock, minStockLevel):
2244 
    """
2245 
    Parameters:
2246 
     - item_id
2247 
     - numOfDaysStock
2248 
     - minStockLevel
2249 
    """
2250 
    self.send_updateItemStockPurchaseParams(item_id, numOfDaysStock, minStockLevel)
2251 
    self.recv_updateItemStockPurchaseParams()
6531 vikram.rag 2252 
 
6821 amar.kumar 2253 
  def send_updateItemStockPurchaseParams(self, item_id, numOfDaysStock, minStockLevel):
2254 
    self._oprot.writeMessageBegin('updateItemStockPurchaseParams', TMessageType.CALL, self._seqid)
2255 
    args = updateItemStockPurchaseParams_args()
2256 
    args.item_id = item_id
2257 
    args.numOfDaysStock = numOfDaysStock
2258 
    args.minStockLevel = minStockLevel
2259 
    args.write(self._oprot)
2260 
    self._oprot.writeMessageEnd()
2261 
    self._oprot.trans.flush()
2262 
 
2263 
  def recv_updateItemStockPurchaseParams(self, ):
2264 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2265 
    if mtype == TMessageType.EXCEPTION:
2266 
      x = TApplicationException()
2267 
      x.read(self._iprot)
2268 
      self._iprot.readMessageEnd()
2269 
      raise x
2270 
    result = updateItemStockPurchaseParams_result()
2271 
    result.read(self._iprot)
2272 
    self._iprot.readMessageEnd()
2273 
    return
2274 
 
2275 
  def getItemStockPurchaseParams(self, itemId):
2276 
    """
2277 
    Parameters:
2278 
     - itemId
2279 
    """
2280 
    self.send_getItemStockPurchaseParams(itemId)
2281 
    return self.recv_getItemStockPurchaseParams()
2282 
 
2283 
  def send_getItemStockPurchaseParams(self, itemId):
2284 
    self._oprot.writeMessageBegin('getItemStockPurchaseParams', TMessageType.CALL, self._seqid)
2285 
    args = getItemStockPurchaseParams_args()
2286 
    args.itemId = itemId
2287 
    args.write(self._oprot)
2288 
    self._oprot.writeMessageEnd()
2289 
    self._oprot.trans.flush()
2290 
 
2291 
  def recv_getItemStockPurchaseParams(self, ):
2292 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2293 
    if mtype == TMessageType.EXCEPTION:
2294 
      x = TApplicationException()
2295 
      x.read(self._iprot)
2296 
      self._iprot.readMessageEnd()
2297 
      raise x
2298 
    result = getItemStockPurchaseParams_result()
2299 
    result.read(self._iprot)
2300 
    self._iprot.readMessageEnd()
2301 
    if result.success is not None:
2302 
      return result.success
2303 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStockPurchaseParams failed: unknown result");
2304 
 
2305 
  def addOosStatusForItem(self, oosStatusMap, date):
2306 
    """
2307 
    Parameters:
2308 
     - oosStatusMap
2309 
     - date
2310 
    """
2311 
    self.send_addOosStatusForItem(oosStatusMap, date)
2312 
    self.recv_addOosStatusForItem()
2313 
 
2314 
  def send_addOosStatusForItem(self, oosStatusMap, date):
2315 
    self._oprot.writeMessageBegin('addOosStatusForItem', TMessageType.CALL, self._seqid)
2316 
    args = addOosStatusForItem_args()
2317 
    args.oosStatusMap = oosStatusMap
2318 
    args.date = date
2319 
    args.write(self._oprot)
2320 
    self._oprot.writeMessageEnd()
2321 
    self._oprot.trans.flush()
2322 
 
2323 
  def recv_addOosStatusForItem(self, ):
2324 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2325 
    if mtype == TMessageType.EXCEPTION:
2326 
      x = TApplicationException()
2327 
      x.read(self._iprot)
2328 
      self._iprot.readMessageEnd()
2329 
      raise x
2330 
    result = addOosStatusForItem_result()
2331 
    result.read(self._iprot)
2332 
    self._iprot.readMessageEnd()
2333 
    return
2334 
 
9762 amar.kumar 2335 
  def getOosStatusesForXDaysForItem(self, itemId, sourceId, days):
6832 amar.kumar 2336 
    """
2337 
    Parameters:
2338 
     - itemId
9762 amar.kumar 2339 
     - sourceId
6832 amar.kumar 2340 
     - days
2341 
    """
9762 amar.kumar 2342 
    self.send_getOosStatusesForXDaysForItem(itemId, sourceId, days)
6832 amar.kumar 2343 
    return self.recv_getOosStatusesForXDaysForItem()
6821 amar.kumar 2344 
 
9762 amar.kumar 2345 
  def send_getOosStatusesForXDaysForItem(self, itemId, sourceId, days):
6832 amar.kumar 2346 
    self._oprot.writeMessageBegin('getOosStatusesForXDaysForItem', TMessageType.CALL, self._seqid)
2347 
    args = getOosStatusesForXDaysForItem_args()
2348 
    args.itemId = itemId
9762 amar.kumar 2349 
    args.sourceId = sourceId
6832 amar.kumar 2350 
    args.days = days
2351 
    args.write(self._oprot)
2352 
    self._oprot.writeMessageEnd()
2353 
    self._oprot.trans.flush()
2354 
 
2355 
  def recv_getOosStatusesForXDaysForItem(self, ):
2356 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2357 
    if mtype == TMessageType.EXCEPTION:
2358 
      x = TApplicationException()
2359 
      x.read(self._iprot)
2360 
      self._iprot.readMessageEnd()
2361 
      raise x
2362 
    result = getOosStatusesForXDaysForItem_result()
2363 
    result.read(self._iprot)
2364 
    self._iprot.readMessageEnd()
2365 
    if result.success is not None:
2366 
      return result.success
2367 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOosStatusesForXDaysForItem failed: unknown result");
2368 
 
10126 amar.kumar 2369 
  def getOosStatusesForXDays(self, sourceId, days):
2370 
    """
2371 
    Parameters:
2372 
     - sourceId
2373 
     - days
2374 
    """
2375 
    self.send_getOosStatusesForXDays(sourceId, days)
2376 
    return self.recv_getOosStatusesForXDays()
2377 
 
2378 
  def send_getOosStatusesForXDays(self, sourceId, days):
2379 
    self._oprot.writeMessageBegin('getOosStatusesForXDays', TMessageType.CALL, self._seqid)
2380 
    args = getOosStatusesForXDays_args()
2381 
    args.sourceId = sourceId
2382 
    args.days = days
2383 
    args.write(self._oprot)
2384 
    self._oprot.writeMessageEnd()
2385 
    self._oprot.trans.flush()
2386 
 
2387 
  def recv_getOosStatusesForXDays(self, ):
2388 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2389 
    if mtype == TMessageType.EXCEPTION:
2390 
      x = TApplicationException()
2391 
      x.read(self._iprot)
2392 
      self._iprot.readMessageEnd()
2393 
      raise x
2394 
    result = getOosStatusesForXDays_result()
2395 
    result.read(self._iprot)
2396 
    self._iprot.readMessageEnd()
2397 
    if result.success is not None:
2398 
      return result.success
2399 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOosStatusesForXDays failed: unknown result");
2400 
 
2401 
  def getAllVendorItemPricing(self, itemId, vendorId):
2402 
    """
2403 
    Parameters:
2404 
     - itemId
2405 
     - vendorId
2406 
    """
2407 
    self.send_getAllVendorItemPricing(itemId, vendorId)
2408 
    return self.recv_getAllVendorItemPricing()
2409 
 
2410 
  def send_getAllVendorItemPricing(self, itemId, vendorId):
2411 
    self._oprot.writeMessageBegin('getAllVendorItemPricing', TMessageType.CALL, self._seqid)
2412 
    args = getAllVendorItemPricing_args()
2413 
    args.itemId = itemId
2414 
    args.vendorId = vendorId
2415 
    args.write(self._oprot)
2416 
    self._oprot.writeMessageEnd()
2417 
    self._oprot.trans.flush()
2418 
 
2419 
  def recv_getAllVendorItemPricing(self, ):
2420 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2421 
    if mtype == TMessageType.EXCEPTION:
2422 
      x = TApplicationException()
2423 
      x.read(self._iprot)
2424 
      self._iprot.readMessageEnd()
2425 
      raise x
2426 
    result = getAllVendorItemPricing_result()
2427 
    result.read(self._iprot)
2428 
    self._iprot.readMessageEnd()
2429 
    if result.success is not None:
2430 
      return result.success
2431 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVendorItemPricing failed: unknown result");
2432 
 
6857 amar.kumar 2433 
  def getNonZeroItemStockPurchaseParams(self, ):
2434 
    self.send_getNonZeroItemStockPurchaseParams()
2435 
    return self.recv_getNonZeroItemStockPurchaseParams()
6832 amar.kumar 2436 
 
6857 amar.kumar 2437 
  def send_getNonZeroItemStockPurchaseParams(self, ):
2438 
    self._oprot.writeMessageBegin('getNonZeroItemStockPurchaseParams', TMessageType.CALL, self._seqid)
2439 
    args = getNonZeroItemStockPurchaseParams_args()
2440 
    args.write(self._oprot)
2441 
    self._oprot.writeMessageEnd()
2442 
    self._oprot.trans.flush()
2443 
 
2444 
  def recv_getNonZeroItemStockPurchaseParams(self, ):
2445 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2446 
    if mtype == TMessageType.EXCEPTION:
2447 
      x = TApplicationException()
2448 
      x.read(self._iprot)
2449 
      self._iprot.readMessageEnd()
2450 
      raise x
2451 
    result = getNonZeroItemStockPurchaseParams_result()
2452 
    result.read(self._iprot)
2453 
    self._iprot.readMessageEnd()
2454 
    if result.success is not None:
2455 
      return result.success
2456 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonZeroItemStockPurchaseParams failed: unknown result");
2457 
 
7149 amar.kumar 2458 
  def getBillableInventoryAndPendingOrders(self, ):
2459 
    """
2460 
    Returns a list of inventory stock for items for which there are pending orders or have billable inventory.
2461 
    """
2462 
    self.send_getBillableInventoryAndPendingOrders()
2463 
    return self.recv_getBillableInventoryAndPendingOrders()
6857 amar.kumar 2464 
 
7149 amar.kumar 2465 
  def send_getBillableInventoryAndPendingOrders(self, ):
2466 
    self._oprot.writeMessageBegin('getBillableInventoryAndPendingOrders', TMessageType.CALL, self._seqid)
2467 
    args = getBillableInventoryAndPendingOrders_args()
2468 
    args.write(self._oprot)
2469 
    self._oprot.writeMessageEnd()
2470 
    self._oprot.trans.flush()
2471 
 
2472 
  def recv_getBillableInventoryAndPendingOrders(self, ):
2473 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2474 
    if mtype == TMessageType.EXCEPTION:
2475 
      x = TApplicationException()
2476 
      x.read(self._iprot)
2477 
      self._iprot.readMessageEnd()
2478 
      raise x
2479 
    result = getBillableInventoryAndPendingOrders_result()
2480 
    result.read(self._iprot)
2481 
    self._iprot.readMessageEnd()
2482 
    if result.success is not None:
2483 
      return result.success
2484 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBillableInventoryAndPendingOrders failed: unknown result");
2485 
 
7281 kshitij.so 2486 
  def getWarehouseName(self, warehouse_id):
2487 
    """
2488 
    Parameters:
2489 
     - warehouse_id
2490 
    """
2491 
    self.send_getWarehouseName(warehouse_id)
2492 
    return self.recv_getWarehouseName()
7149 amar.kumar 2493 
 
7281 kshitij.so 2494 
  def send_getWarehouseName(self, warehouse_id):
2495 
    self._oprot.writeMessageBegin('getWarehouseName', TMessageType.CALL, self._seqid)
2496 
    args = getWarehouseName_args()
2497 
    args.warehouse_id = warehouse_id
2498 
    args.write(self._oprot)
2499 
    self._oprot.writeMessageEnd()
2500 
    self._oprot.trans.flush()
2501 
 
2502 
  def recv_getWarehouseName(self, ):
2503 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2504 
    if mtype == TMessageType.EXCEPTION:
2505 
      x = TApplicationException()
2506 
      x.read(self._iprot)
2507 
      self._iprot.readMessageEnd()
2508 
      raise x
2509 
    result = getWarehouseName_result()
2510 
    result.read(self._iprot)
2511 
    self._iprot.readMessageEnd()
2512 
    if result.success is not None:
2513 
      return result.success
2514 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getWarehouseName failed: unknown result");
2515 
 
2516 
  def getAmazonInventoryForItem(self, item_id):
2517 
    """
2518 
    Parameters:
2519 
     - item_id
2520 
    """
2521 
    self.send_getAmazonInventoryForItem(item_id)
2522 
    return self.recv_getAmazonInventoryForItem()
2523 
 
2524 
  def send_getAmazonInventoryForItem(self, item_id):
2525 
    self._oprot.writeMessageBegin('getAmazonInventoryForItem', TMessageType.CALL, self._seqid)
2526 
    args = getAmazonInventoryForItem_args()
2527 
    args.item_id = item_id
2528 
    args.write(self._oprot)
2529 
    self._oprot.writeMessageEnd()
2530 
    self._oprot.trans.flush()
2531 
 
2532 
  def recv_getAmazonInventoryForItem(self, ):
2533 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2534 
    if mtype == TMessageType.EXCEPTION:
2535 
      x = TApplicationException()
2536 
      x.read(self._iprot)
2537 
      self._iprot.readMessageEnd()
2538 
      raise x
2539 
    result = getAmazonInventoryForItem_result()
2540 
    result.read(self._iprot)
2541 
    self._iprot.readMessageEnd()
2542 
    if result.success is not None:
2543 
      return result.success
2544 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonInventoryForItem failed: unknown result");
2545 
 
2546 
  def getAllAmazonInventory(self, ):
2547 
    self.send_getAllAmazonInventory()
2548 
    return self.recv_getAllAmazonInventory()
2549 
 
2550 
  def send_getAllAmazonInventory(self, ):
2551 
    self._oprot.writeMessageBegin('getAllAmazonInventory', TMessageType.CALL, self._seqid)
2552 
    args = getAllAmazonInventory_args()
2553 
    args.write(self._oprot)
2554 
    self._oprot.writeMessageEnd()
2555 
    self._oprot.trans.flush()
2556 
 
2557 
  def recv_getAllAmazonInventory(self, ):
2558 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2559 
    if mtype == TMessageType.EXCEPTION:
2560 
      x = TApplicationException()
2561 
      x.read(self._iprot)
2562 
      self._iprot.readMessageEnd()
2563 
      raise x
2564 
    result = getAllAmazonInventory_result()
2565 
    result.read(self._iprot)
2566 
    self._iprot.readMessageEnd()
2567 
    if result.success is not None:
2568 
      return result.success
2569 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonInventory failed: unknown result");
2570 
 
10450 vikram.rag 2571 
  def addOrUpdateAmazonInventoryForItem(self, amazonInventorySnapshot, time):
7281 kshitij.so 2572 
    """
2573 
    Parameters:
2574 
     - amazonInventorySnapshot
10450 vikram.rag 2575 
     - time
7281 kshitij.so 2576 
    """
10450 vikram.rag 2577 
    self.send_addOrUpdateAmazonInventoryForItem(amazonInventorySnapshot, time)
7281 kshitij.so 2578 
    self.recv_addOrUpdateAmazonInventoryForItem()
2579 
 
10450 vikram.rag 2580 
  def send_addOrUpdateAmazonInventoryForItem(self, amazonInventorySnapshot, time):
7281 kshitij.so 2581 
    self._oprot.writeMessageBegin('addOrUpdateAmazonInventoryForItem', TMessageType.CALL, self._seqid)
2582 
    args = addOrUpdateAmazonInventoryForItem_args()
2583 
    args.amazonInventorySnapshot = amazonInventorySnapshot
10450 vikram.rag 2584 
    args.time = time
7281 kshitij.so 2585 
    args.write(self._oprot)
2586 
    self._oprot.writeMessageEnd()
2587 
    self._oprot.trans.flush()
2588 
 
2589 
  def recv_addOrUpdateAmazonInventoryForItem(self, ):
2590 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2591 
    if mtype == TMessageType.EXCEPTION:
2592 
      x = TApplicationException()
2593 
      x.read(self._iprot)
2594 
      self._iprot.readMessageEnd()
2595 
      raise x
2596 
    result = addOrUpdateAmazonInventoryForItem_result()
2597 
    result.read(self._iprot)
2598 
    self._iprot.readMessageEnd()
2599 
    return
2600 
 
7972 amar.kumar 2601 
  def getLastNdaySaleForItem(self, itemId, numberOfDays):
2602 
    """
2603 
    Parameters:
2604 
     - itemId
2605 
     - numberOfDays
2606 
    """
2607 
    self.send_getLastNdaySaleForItem(itemId, numberOfDays)
2608 
    return self.recv_getLastNdaySaleForItem()
7281 kshitij.so 2609 
 
7972 amar.kumar 2610 
  def send_getLastNdaySaleForItem(self, itemId, numberOfDays):
2611 
    self._oprot.writeMessageBegin('getLastNdaySaleForItem', TMessageType.CALL, self._seqid)
2612 
    args = getLastNdaySaleForItem_args()
2613 
    args.itemId = itemId
2614 
    args.numberOfDays = numberOfDays
2615 
    args.write(self._oprot)
2616 
    self._oprot.writeMessageEnd()
2617 
    self._oprot.trans.flush()
2618 
 
2619 
  def recv_getLastNdaySaleForItem(self, ):
2620 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2621 
    if mtype == TMessageType.EXCEPTION:
2622 
      x = TApplicationException()
2623 
      x.read(self._iprot)
2624 
      self._iprot.readMessageEnd()
2625 
      raise x
2626 
    result = getLastNdaySaleForItem_result()
2627 
    result.read(self._iprot)
2628 
    self._iprot.readMessageEnd()
2629 
    if result.success is not None:
2630 
      return result.success
2631 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLastNdaySaleForItem failed: unknown result");
2632 
 
8282 kshitij.so 2633 
  def addOrUpdateAmazonFbaInventory(self, amazonfbainventorysnapshot):
2634 
    """
2635 
    Parameters:
2636 
     - amazonfbainventorysnapshot
2637 
    """
2638 
    self.send_addOrUpdateAmazonFbaInventory(amazonfbainventorysnapshot)
2639 
    self.recv_addOrUpdateAmazonFbaInventory()
2640 
 
2641 
  def send_addOrUpdateAmazonFbaInventory(self, amazonfbainventorysnapshot):
2642 
    self._oprot.writeMessageBegin('addOrUpdateAmazonFbaInventory', TMessageType.CALL, self._seqid)
2643 
    args = addOrUpdateAmazonFbaInventory_args()
2644 
    args.amazonfbainventorysnapshot = amazonfbainventorysnapshot
2645 
    args.write(self._oprot)
2646 
    self._oprot.writeMessageEnd()
2647 
    self._oprot.trans.flush()
2648 
 
2649 
  def recv_addOrUpdateAmazonFbaInventory(self, ):
2650 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2651 
    if mtype == TMessageType.EXCEPTION:
2652 
      x = TApplicationException()
2653 
      x.read(self._iprot)
2654 
      self._iprot.readMessageEnd()
2655 
      raise x
2656 
    result = addOrUpdateAmazonFbaInventory_result()
2657 
    result.read(self._iprot)
2658 
    self._iprot.readMessageEnd()
2659 
    return
2660 
 
8182 amar.kumar 2661 
  def addUpdateHoldInventory(self, itemId, warehouseId, holdQuantity, source):
2662 
    """
2663 
    Parameters:
2664 
     - itemId
2665 
     - warehouseId
2666 
     - holdQuantity
2667 
     - source
2668 
    """
2669 
    self.send_addUpdateHoldInventory(itemId, warehouseId, holdQuantity, source)
2670 
    self.recv_addUpdateHoldInventory()
7972 amar.kumar 2671 
 
8182 amar.kumar 2672 
  def send_addUpdateHoldInventory(self, itemId, warehouseId, holdQuantity, source):
2673 
    self._oprot.writeMessageBegin('addUpdateHoldInventory', TMessageType.CALL, self._seqid)
2674 
    args = addUpdateHoldInventory_args()
2675 
    args.itemId = itemId
2676 
    args.warehouseId = warehouseId
2677 
    args.holdQuantity = holdQuantity
2678 
    args.source = source
2679 
    args.write(self._oprot)
2680 
    self._oprot.writeMessageEnd()
2681 
    self._oprot.trans.flush()
2682 
 
2683 
  def recv_addUpdateHoldInventory(self, ):
2684 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2685 
    if mtype == TMessageType.EXCEPTION:
2686 
      x = TApplicationException()
2687 
      x.read(self._iprot)
2688 
      self._iprot.readMessageEnd()
2689 
      raise x
2690 
    result = addUpdateHoldInventory_result()
2691 
    result.read(self._iprot)
2692 
    self._iprot.readMessageEnd()
9762 amar.kumar 2693 
    if result.cex is not None:
2694 
      raise result.cex
8182 amar.kumar 2695 
    return
2696 
 
8282 kshitij.so 2697 
  def getAmazonFbaItemInventory(self, itemId):
2698 
    """
2699 
    Parameters:
2700 
     - itemId
2701 
    """
2702 
    self.send_getAmazonFbaItemInventory(itemId)
2703 
    return self.recv_getAmazonFbaItemInventory()
8182 amar.kumar 2704 
 
8282 kshitij.so 2705 
  def send_getAmazonFbaItemInventory(self, itemId):
2706 
    self._oprot.writeMessageBegin('getAmazonFbaItemInventory', TMessageType.CALL, self._seqid)
2707 
    args = getAmazonFbaItemInventory_args()
2708 
    args.itemId = itemId
2709 
    args.write(self._oprot)
2710 
    self._oprot.writeMessageEnd()
2711 
    self._oprot.trans.flush()
2712 
 
2713 
  def recv_getAmazonFbaItemInventory(self, ):
2714 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2715 
    if mtype == TMessageType.EXCEPTION:
2716 
      x = TApplicationException()
2717 
      x.read(self._iprot)
2718 
      self._iprot.readMessageEnd()
2719 
      raise x
2720 
    result = getAmazonFbaItemInventory_result()
2721 
    result.read(self._iprot)
2722 
    self._iprot.readMessageEnd()
2723 
    if result.success is not None:
2724 
      return result.success
2725 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonFbaItemInventory failed: unknown result");
2726 
 
8363 vikram.rag 2727 
  def getAllAmazonFbaItemInventory(self, ):
2728 
    self.send_getAllAmazonFbaItemInventory()
2729 
    return self.recv_getAllAmazonFbaItemInventory()
8282 kshitij.so 2730 
 
8363 vikram.rag 2731 
  def send_getAllAmazonFbaItemInventory(self, ):
2732 
    self._oprot.writeMessageBegin('getAllAmazonFbaItemInventory', TMessageType.CALL, self._seqid)
2733 
    args = getAllAmazonFbaItemInventory_args()
8282 kshitij.so 2734 
    args.write(self._oprot)
2735 
    self._oprot.writeMessageEnd()
2736 
    self._oprot.trans.flush()
2737 
 
8363 vikram.rag 2738 
  def recv_getAllAmazonFbaItemInventory(self, ):
8282 kshitij.so 2739 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2740 
    if mtype == TMessageType.EXCEPTION:
2741 
      x = TApplicationException()
2742 
      x.read(self._iprot)
2743 
      self._iprot.readMessageEnd()
2744 
      raise x
8363 vikram.rag 2745 
    result = getAllAmazonFbaItemInventory_result()
8282 kshitij.so 2746 
    result.read(self._iprot)
2747 
    self._iprot.readMessageEnd()
2748 
    if result.success is not None:
2749 
      return result.success
8363 vikram.rag 2750 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonFbaItemInventory failed: unknown result");
8282 kshitij.so 2751 
 
8363 vikram.rag 2752 
  def getOursGoodWarehouseIdsForLocation(self, state_id):
2753 
    """
2754 
    Parameters:
2755 
     - state_id
2756 
    """
2757 
    self.send_getOursGoodWarehouseIdsForLocation(state_id)
2758 
    return self.recv_getOursGoodWarehouseIdsForLocation()
8282 kshitij.so 2759 
 
8363 vikram.rag 2760 
  def send_getOursGoodWarehouseIdsForLocation(self, state_id):
2761 
    self._oprot.writeMessageBegin('getOursGoodWarehouseIdsForLocation', TMessageType.CALL, self._seqid)
2762 
    args = getOursGoodWarehouseIdsForLocation_args()
2763 
    args.state_id = state_id
2764 
    args.write(self._oprot)
2765 
    self._oprot.writeMessageEnd()
2766 
    self._oprot.trans.flush()
2767 
 
2768 
  def recv_getOursGoodWarehouseIdsForLocation(self, ):
2769 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2770 
    if mtype == TMessageType.EXCEPTION:
2771 
      x = TApplicationException()
2772 
      x.read(self._iprot)
2773 
      self._iprot.readMessageEnd()
2774 
      raise x
2775 
    result = getOursGoodWarehouseIdsForLocation_result()
2776 
    result.read(self._iprot)
2777 
    self._iprot.readMessageEnd()
2778 
    if result.success is not None:
2779 
      return result.success
2780 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOursGoodWarehouseIdsForLocation failed: unknown result");
2781 
 
8955 vikram.rag 2782 
  def getHoldInventoryDetailForItemForWarehouseIdExceptSource(self, id, warehouse_id, source):
2783 
    """
2784 
    Parameters:
2785 
     - id
2786 
     - warehouse_id
2787 
     - source
2788 
    """
2789 
    self.send_getHoldInventoryDetailForItemForWarehouseIdExceptSource(id, warehouse_id, source)
2790 
    return self.recv_getHoldInventoryDetailForItemForWarehouseIdExceptSource()
8363 vikram.rag 2791 
 
8955 vikram.rag 2792 
  def send_getHoldInventoryDetailForItemForWarehouseIdExceptSource(self, id, warehouse_id, source):
2793 
    self._oprot.writeMessageBegin('getHoldInventoryDetailForItemForWarehouseIdExceptSource', TMessageType.CALL, self._seqid)
2794 
    args = getHoldInventoryDetailForItemForWarehouseIdExceptSource_args()
2795 
    args.id = id
2796 
    args.warehouse_id = warehouse_id
2797 
    args.source = source
2798 
    args.write(self._oprot)
2799 
    self._oprot.writeMessageEnd()
2800 
    self._oprot.trans.flush()
2801 
 
2802 
  def recv_getHoldInventoryDetailForItemForWarehouseIdExceptSource(self, ):
2803 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2804 
    if mtype == TMessageType.EXCEPTION:
2805 
      x = TApplicationException()
2806 
      x.read(self._iprot)
2807 
      self._iprot.readMessageEnd()
2808 
      raise x
2809 
    result = getHoldInventoryDetailForItemForWarehouseIdExceptSource_result()
2810 
    result.read(self._iprot)
2811 
    self._iprot.readMessageEnd()
2812 
    if result.success is not None:
2813 
      return result.success
2814 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getHoldInventoryDetailForItemForWarehouseIdExceptSource failed: unknown result");
2815 
 
9404 vikram.rag 2816 
  def getSnapdealInventoryForItem(self, item_id):
2817 
    """
2818 
    Parameters:
2819 
     - item_id
2820 
    """
2821 
    self.send_getSnapdealInventoryForItem(item_id)
2822 
    return self.recv_getSnapdealInventoryForItem()
8955 vikram.rag 2823 
 
9404 vikram.rag 2824 
  def send_getSnapdealInventoryForItem(self, item_id):
2825 
    self._oprot.writeMessageBegin('getSnapdealInventoryForItem', TMessageType.CALL, self._seqid)
2826 
    args = getSnapdealInventoryForItem_args()
2827 
    args.item_id = item_id
2828 
    args.write(self._oprot)
2829 
    self._oprot.writeMessageEnd()
2830 
    self._oprot.trans.flush()
2831 
 
2832 
  def recv_getSnapdealInventoryForItem(self, ):
2833 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2834 
    if mtype == TMessageType.EXCEPTION:
2835 
      x = TApplicationException()
2836 
      x.read(self._iprot)
2837 
      self._iprot.readMessageEnd()
2838 
      raise x
2839 
    result = getSnapdealInventoryForItem_result()
2840 
    result.read(self._iprot)
2841 
    self._iprot.readMessageEnd()
2842 
    if result.success is not None:
2843 
      return result.success
2844 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealInventoryForItem failed: unknown result");
2845 
 
2846 
  def addOrUpdateSnapdealInventoryForItem(self, snapdealinventoryitem):
2847 
    """
2848 
    Parameters:
2849 
     - snapdealinventoryitem
2850 
    """
2851 
    self.send_addOrUpdateSnapdealInventoryForItem(snapdealinventoryitem)
2852 
    self.recv_addOrUpdateSnapdealInventoryForItem()
2853 
 
2854 
  def send_addOrUpdateSnapdealInventoryForItem(self, snapdealinventoryitem):
2855 
    self._oprot.writeMessageBegin('addOrUpdateSnapdealInventoryForItem', TMessageType.CALL, self._seqid)
2856 
    args = addOrUpdateSnapdealInventoryForItem_args()
2857 
    args.snapdealinventoryitem = snapdealinventoryitem
2858 
    args.write(self._oprot)
2859 
    self._oprot.writeMessageEnd()
2860 
    self._oprot.trans.flush()
2861 
 
2862 
  def recv_addOrUpdateSnapdealInventoryForItem(self, ):
2863 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2864 
    if mtype == TMessageType.EXCEPTION:
2865 
      x = TApplicationException()
2866 
      x.read(self._iprot)
2867 
      self._iprot.readMessageEnd()
2868 
      raise x
2869 
    result = addOrUpdateSnapdealInventoryForItem_result()
2870 
    result.read(self._iprot)
2871 
    self._iprot.readMessageEnd()
2872 
    return
2873 
 
2874 
  def getNlcForWarehouse(self, warehouse_id, item_id):
2875 
    """
2876 
    Parameters:
2877 
     - warehouse_id
2878 
     - item_id
2879 
    """
2880 
    self.send_getNlcForWarehouse(warehouse_id, item_id)
2881 
    return self.recv_getNlcForWarehouse()
2882 
 
2883 
  def send_getNlcForWarehouse(self, warehouse_id, item_id):
2884 
    self._oprot.writeMessageBegin('getNlcForWarehouse', TMessageType.CALL, self._seqid)
2885 
    args = getNlcForWarehouse_args()
2886 
    args.warehouse_id = warehouse_id
2887 
    args.item_id = item_id
2888 
    args.write(self._oprot)
2889 
    self._oprot.writeMessageEnd()
2890 
    self._oprot.trans.flush()
2891 
 
2892 
  def recv_getNlcForWarehouse(self, ):
2893 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2894 
    if mtype == TMessageType.EXCEPTION:
2895 
      x = TApplicationException()
2896 
      x.read(self._iprot)
2897 
      self._iprot.readMessageEnd()
2898 
      raise x
2899 
    result = getNlcForWarehouse_result()
2900 
    result.read(self._iprot)
2901 
    self._iprot.readMessageEnd()
2902 
    if result.success is not None:
2903 
      return result.success
2904 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNlcForWarehouse failed: unknown result");
2905 
 
9640 amar.kumar 2906 
  def getHeldInventoryMapForItem(self, item_id, warehouse_id):
2907 
    """
2908 
    Parameters:
2909 
     - item_id
2910 
     - warehouse_id
2911 
    """
2912 
    self.send_getHeldInventoryMapForItem(item_id, warehouse_id)
2913 
    return self.recv_getHeldInventoryMapForItem()
2914 
 
2915 
  def send_getHeldInventoryMapForItem(self, item_id, warehouse_id):
2916 
    self._oprot.writeMessageBegin('getHeldInventoryMapForItem', TMessageType.CALL, self._seqid)
2917 
    args = getHeldInventoryMapForItem_args()
2918 
    args.item_id = item_id
2919 
    args.warehouse_id = warehouse_id
2920 
    args.write(self._oprot)
2921 
    self._oprot.writeMessageEnd()
2922 
    self._oprot.trans.flush()
2923 
 
2924 
  def recv_getHeldInventoryMapForItem(self, ):
2925 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2926 
    if mtype == TMessageType.EXCEPTION:
2927 
      x = TApplicationException()
2928 
      x.read(self._iprot)
2929 
      self._iprot.readMessageEnd()
2930 
      raise x
2931 
    result = getHeldInventoryMapForItem_result()
2932 
    result.read(self._iprot)
2933 
    self._iprot.readMessageEnd()
2934 
    if result.success is not None:
2935 
      return result.success
2936 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getHeldInventoryMapForItem failed: unknown result");
2937 
 
9495 vikram.rag 2938 
  def addOrUpdateAllAmazonFbaInventory(self, allamazonfbainventorysnapshot):
2939 
    """
2940 
    Parameters:
2941 
     - allamazonfbainventorysnapshot
2942 
    """
2943 
    self.send_addOrUpdateAllAmazonFbaInventory(allamazonfbainventorysnapshot)
2944 
    self.recv_addOrUpdateAllAmazonFbaInventory()
9404 vikram.rag 2945 
 
9495 vikram.rag 2946 
  def send_addOrUpdateAllAmazonFbaInventory(self, allamazonfbainventorysnapshot):
2947 
    self._oprot.writeMessageBegin('addOrUpdateAllAmazonFbaInventory', TMessageType.CALL, self._seqid)
2948 
    args = addOrUpdateAllAmazonFbaInventory_args()
2949 
    args.allamazonfbainventorysnapshot = allamazonfbainventorysnapshot
9456 vikram.rag 2950 
    args.write(self._oprot)
2951 
    self._oprot.writeMessageEnd()
2952 
    self._oprot.trans.flush()
2953 
 
9495 vikram.rag 2954 
  def recv_addOrUpdateAllAmazonFbaInventory(self, ):
9456 vikram.rag 2955 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2956 
    if mtype == TMessageType.EXCEPTION:
2957 
      x = TApplicationException()
2958 
      x.read(self._iprot)
2959 
      self._iprot.readMessageEnd()
2960 
      raise x
9495 vikram.rag 2961 
    result = addOrUpdateAllAmazonFbaInventory_result()
9456 vikram.rag 2962 
    result.read(self._iprot)
2963 
    self._iprot.readMessageEnd()
9495 vikram.rag 2964 
    return
9456 vikram.rag 2965 
 
9495 vikram.rag 2966 
  def addOrUpdateAllSnapdealInventory(self, allsnapdealinventorysnapshot):
9482 vikram.rag 2967 
    """
2968 
    Parameters:
9495 vikram.rag 2969 
     - allsnapdealinventorysnapshot
9482 vikram.rag 2970 
    """
9495 vikram.rag 2971 
    self.send_addOrUpdateAllSnapdealInventory(allsnapdealinventorysnapshot)
2972 
    self.recv_addOrUpdateAllSnapdealInventory()
9456 vikram.rag 2973 
 
9495 vikram.rag 2974 
  def send_addOrUpdateAllSnapdealInventory(self, allsnapdealinventorysnapshot):
2975 
    self._oprot.writeMessageBegin('addOrUpdateAllSnapdealInventory', TMessageType.CALL, self._seqid)
2976 
    args = addOrUpdateAllSnapdealInventory_args()
2977 
    args.allsnapdealinventorysnapshot = allsnapdealinventorysnapshot
9482 vikram.rag 2978 
    args.write(self._oprot)
2979 
    self._oprot.writeMessageEnd()
2980 
    self._oprot.trans.flush()
2981 
 
9495 vikram.rag 2982 
  def recv_addOrUpdateAllSnapdealInventory(self, ):
9482 vikram.rag 2983 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2984 
    if mtype == TMessageType.EXCEPTION:
2985 
      x = TApplicationException()
2986 
      x.read(self._iprot)
2987 
      self._iprot.readMessageEnd()
2988 
      raise x
9495 vikram.rag 2989 
    result = addOrUpdateAllSnapdealInventory_result()
9482 vikram.rag 2990 
    result.read(self._iprot)
2991 
    self._iprot.readMessageEnd()
2992 
    return
2993 
 
9495 vikram.rag 2994 
  def getSnapdealInventorySnapshot(self, ):
2995 
    self.send_getSnapdealInventorySnapshot()
2996 
    return self.recv_getSnapdealInventorySnapshot()
9482 vikram.rag 2997 
 
9495 vikram.rag 2998 
  def send_getSnapdealInventorySnapshot(self, ):
2999 
    self._oprot.writeMessageBegin('getSnapdealInventorySnapshot', TMessageType.CALL, self._seqid)
3000 
    args = getSnapdealInventorySnapshot_args()
3001 
    args.write(self._oprot)
3002 
    self._oprot.writeMessageEnd()
3003 
    self._oprot.trans.flush()
3004 
 
3005 
  def recv_getSnapdealInventorySnapshot(self, ):
3006 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3007 
    if mtype == TMessageType.EXCEPTION:
3008 
      x = TApplicationException()
3009 
      x.read(self._iprot)
3010 
      self._iprot.readMessageEnd()
3011 
      raise x
3012 
    result = getSnapdealInventorySnapshot_result()
3013 
    result.read(self._iprot)
3014 
    self._iprot.readMessageEnd()
3015 
    if result.success is not None:
3016 
      return result.success
3017 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealInventorySnapshot failed: unknown result");
3018 
 
9761 amar.kumar 3019 
  def getHoldInventoryDetails(self, itemId, warehouseId, source):
3020 
    """
3021 
    Parameters:
3022 
     - itemId
3023 
     - warehouseId
3024 
     - source
3025 
    """
3026 
    self.send_getHoldInventoryDetails(itemId, warehouseId, source)
3027 
    return self.recv_getHoldInventoryDetails()
9495 vikram.rag 3028 
 
9761 amar.kumar 3029 
  def send_getHoldInventoryDetails(self, itemId, warehouseId, source):
3030 
    self._oprot.writeMessageBegin('getHoldInventoryDetails', TMessageType.CALL, self._seqid)
3031 
    args = getHoldInventoryDetails_args()
3032 
    args.itemId = itemId
3033 
    args.warehouseId = warehouseId
3034 
    args.source = source
3035 
    args.write(self._oprot)
3036 
    self._oprot.writeMessageEnd()
3037 
    self._oprot.trans.flush()
3038 
 
3039 
  def recv_getHoldInventoryDetails(self, ):
3040 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3041 
    if mtype == TMessageType.EXCEPTION:
3042 
      x = TApplicationException()
3043 
      x.read(self._iprot)
3044 
      self._iprot.readMessageEnd()
3045 
      raise x
3046 
    result = getHoldInventoryDetails_result()
3047 
    result.read(self._iprot)
3048 
    self._iprot.readMessageEnd()
3049 
    if result.success is not None:
3050 
      return result.success
3051 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getHoldInventoryDetails failed: unknown result");
3052 
 
10450 vikram.rag 3053 
  def addOrUpdateFlipkartInventorySnapshot(self, flipkartInventorySnapshot, time):
10050 vikram.rag 3054 
    """
3055 
    Parameters:
3056 
     - flipkartInventorySnapshot
10450 vikram.rag 3057 
     - time
10050 vikram.rag 3058 
    """
10450 vikram.rag 3059 
    self.send_addOrUpdateFlipkartInventorySnapshot(flipkartInventorySnapshot, time)
10050 vikram.rag 3060 
    self.recv_addOrUpdateFlipkartInventorySnapshot()
9761 amar.kumar 3061 
 
10450 vikram.rag 3062 
  def send_addOrUpdateFlipkartInventorySnapshot(self, flipkartInventorySnapshot, time):
10050 vikram.rag 3063 
    self._oprot.writeMessageBegin('addOrUpdateFlipkartInventorySnapshot', TMessageType.CALL, self._seqid)
3064 
    args = addOrUpdateFlipkartInventorySnapshot_args()
3065 
    args.flipkartInventorySnapshot = flipkartInventorySnapshot
10450 vikram.rag 3066 
    args.time = time
10050 vikram.rag 3067 
    args.write(self._oprot)
3068 
    self._oprot.writeMessageEnd()
3069 
    self._oprot.trans.flush()
3070 
 
3071 
  def recv_addOrUpdateFlipkartInventorySnapshot(self, ):
3072 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3073 
    if mtype == TMessageType.EXCEPTION:
3074 
      x = TApplicationException()
3075 
      x.read(self._iprot)
3076 
      self._iprot.readMessageEnd()
3077 
      raise x
3078 
    result = addOrUpdateFlipkartInventorySnapshot_result()
3079 
    result.read(self._iprot)
3080 
    self._iprot.readMessageEnd()
3081 
    return
3082 
 
3083 
  def getFlipkartInventorySnapshot(self, ):
3084 
    self.send_getFlipkartInventorySnapshot()
3085 
    return self.recv_getFlipkartInventorySnapshot()
3086 
 
3087 
  def send_getFlipkartInventorySnapshot(self, ):
3088 
    self._oprot.writeMessageBegin('getFlipkartInventorySnapshot', TMessageType.CALL, self._seqid)
3089 
    args = getFlipkartInventorySnapshot_args()
3090 
    args.write(self._oprot)
3091 
    self._oprot.writeMessageEnd()
3092 
    self._oprot.trans.flush()
3093 
 
3094 
  def recv_getFlipkartInventorySnapshot(self, ):
3095 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3096 
    if mtype == TMessageType.EXCEPTION:
3097 
      x = TApplicationException()
3098 
      x.read(self._iprot)
3099 
      self._iprot.readMessageEnd()
3100 
      raise x
3101 
    result = getFlipkartInventorySnapshot_result()
3102 
    result.read(self._iprot)
3103 
    self._iprot.readMessageEnd()
3104 
    if result.success is not None:
3105 
      return result.success
3106 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartInventorySnapshot failed: unknown result");
3107 
 
10097 kshitij.so 3108 
  def getFlipkartlInventoryForItem(self, item_id):
3109 
    """
3110 
    Parameters:
3111 
     - item_id
3112 
    """
3113 
    self.send_getFlipkartlInventoryForItem(item_id)
3114 
    return self.recv_getFlipkartlInventoryForItem()
10050 vikram.rag 3115 
 
10097 kshitij.so 3116 
  def send_getFlipkartlInventoryForItem(self, item_id):
3117 
    self._oprot.writeMessageBegin('getFlipkartlInventoryForItem', TMessageType.CALL, self._seqid)
3118 
    args = getFlipkartlInventoryForItem_args()
3119 
    args.item_id = item_id
3120 
    args.write(self._oprot)
3121 
    self._oprot.writeMessageEnd()
3122 
    self._oprot.trans.flush()
3123 
 
3124 
  def recv_getFlipkartlInventoryForItem(self, ):
3125 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3126 
    if mtype == TMessageType.EXCEPTION:
3127 
      x = TApplicationException()
3128 
      x.read(self._iprot)
3129 
      self._iprot.readMessageEnd()
3130 
      raise x
3131 
    result = getFlipkartlInventoryForItem_result()
3132 
    result.read(self._iprot)
3133 
    self._iprot.readMessageEnd()
3134 
    if result.success is not None:
3135 
      return result.success
3136 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartlInventoryForItem failed: unknown result");
3137 
 
10485 vikram.rag 3138 
  def getStateMaster(self, ):
3139 
    self.send_getStateMaster()
3140 
    return self.recv_getStateMaster()
10097 kshitij.so 3141 
 
10485 vikram.rag 3142 
  def send_getStateMaster(self, ):
3143 
    self._oprot.writeMessageBegin('getStateMaster', TMessageType.CALL, self._seqid)
3144 
    args = getStateMaster_args()
3145 
    args.write(self._oprot)
3146 
    self._oprot.writeMessageEnd()
3147 
    self._oprot.trans.flush()
3148 
 
3149 
  def recv_getStateMaster(self, ):
3150 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3151 
    if mtype == TMessageType.EXCEPTION:
3152 
      x = TApplicationException()
3153 
      x.read(self._iprot)
3154 
      self._iprot.readMessageEnd()
3155 
      raise x
3156 
    result = getStateMaster_result()
3157 
    result.read(self._iprot)
3158 
    self._iprot.readMessageEnd()
3159 
    if result.success is not None:
3160 
      return result.success
3161 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStateMaster failed: unknown result");
3162 
 
10544 vikram.rag 3163 
  def updateSnapdealStockAtEOD(self, allsnapdealstock):
3164 
    """
3165 
    Parameters:
3166 
     - allsnapdealstock
3167 
    """
3168 
    self.send_updateSnapdealStockAtEOD(allsnapdealstock)
3169 
    self.recv_updateSnapdealStockAtEOD()
10485 vikram.rag 3170 
 
10544 vikram.rag 3171 
  def send_updateSnapdealStockAtEOD(self, allsnapdealstock):
3172 
    self._oprot.writeMessageBegin('updateSnapdealStockAtEOD', TMessageType.CALL, self._seqid)
3173 
    args = updateSnapdealStockAtEOD_args()
3174 
    args.allsnapdealstock = allsnapdealstock
3175 
    args.write(self._oprot)
3176 
    self._oprot.writeMessageEnd()
3177 
    self._oprot.trans.flush()
3178 
 
3179 
  def recv_updateSnapdealStockAtEOD(self, ):
3180 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3181 
    if mtype == TMessageType.EXCEPTION:
3182 
      x = TApplicationException()
3183 
      x.read(self._iprot)
3184 
      self._iprot.readMessageEnd()
3185 
      raise x
3186 
    result = updateSnapdealStockAtEOD_result()
3187 
    result.read(self._iprot)
3188 
    self._iprot.readMessageEnd()
3189 
    return
3190 
 
3191 
  def updateFlipkartStockAtEOD(self, allflipkartstock):
3192 
    """
3193 
    Parameters:
3194 
     - allflipkartstock
3195 
    """
3196 
    self.send_updateFlipkartStockAtEOD(allflipkartstock)
3197 
    self.recv_updateFlipkartStockAtEOD()
3198 
 
3199 
  def send_updateFlipkartStockAtEOD(self, allflipkartstock):
3200 
    self._oprot.writeMessageBegin('updateFlipkartStockAtEOD', TMessageType.CALL, self._seqid)
3201 
    args = updateFlipkartStockAtEOD_args()
3202 
    args.allflipkartstock = allflipkartstock
3203 
    args.write(self._oprot)
3204 
    self._oprot.writeMessageEnd()
3205 
    self._oprot.trans.flush()
3206 
 
3207 
  def recv_updateFlipkartStockAtEOD(self, ):
3208 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3209 
    if mtype == TMessageType.EXCEPTION:
3210 
      x = TApplicationException()
3211 
      x.read(self._iprot)
3212 
      self._iprot.readMessageEnd()
3213 
      raise x
3214 
    result = updateFlipkartStockAtEOD_result()
3215 
    result.read(self._iprot)
3216 
    self._iprot.readMessageEnd()
3217 
    return
3218 
 
12363 kshitij.so 3219 
  def getWanNlcForSource(self, item_id, source):
3220 
    """
3221 
    Parameters:
3222 
     - item_id
3223 
     - source
3224 
    """
3225 
    self.send_getWanNlcForSource(item_id, source)
3226 
    return self.recv_getWanNlcForSource()
10544 vikram.rag 3227 
 
12363 kshitij.so 3228 
  def send_getWanNlcForSource(self, item_id, source):
3229 
    self._oprot.writeMessageBegin('getWanNlcForSource', TMessageType.CALL, self._seqid)
3230 
    args = getWanNlcForSource_args()
3231 
    args.item_id = item_id
3232 
    args.source = source
3233 
    args.write(self._oprot)
3234 
    self._oprot.writeMessageEnd()
3235 
    self._oprot.trans.flush()
3236 
 
3237 
  def recv_getWanNlcForSource(self, ):
3238 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3239 
    if mtype == TMessageType.EXCEPTION:
3240 
      x = TApplicationException()
3241 
      x.read(self._iprot)
3242 
      self._iprot.readMessageEnd()
3243 
      raise x
3244 
    result = getWanNlcForSource_result()
3245 
    result.read(self._iprot)
3246 
    self._iprot.readMessageEnd()
3247 
    if result.success is not None:
3248 
      return result.success
3249 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getWanNlcForSource failed: unknown result");
3250 
 
3251 
  def getAllAvailableAmazonFbaItemInventory(self, ):
3252 
    self.send_getAllAvailableAmazonFbaItemInventory()
3253 
    return self.recv_getAllAvailableAmazonFbaItemInventory()
3254 
 
3255 
  def send_getAllAvailableAmazonFbaItemInventory(self, ):
3256 
    self._oprot.writeMessageBegin('getAllAvailableAmazonFbaItemInventory', TMessageType.CALL, self._seqid)
3257 
    args = getAllAvailableAmazonFbaItemInventory_args()
3258 
    args.write(self._oprot)
3259 
    self._oprot.writeMessageEnd()
3260 
    self._oprot.trans.flush()
3261 
 
3262 
  def recv_getAllAvailableAmazonFbaItemInventory(self, ):
3263 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3264 
    if mtype == TMessageType.EXCEPTION:
3265 
      x = TApplicationException()
3266 
      x.read(self._iprot)
3267 
      self._iprot.readMessageEnd()
3268 
      raise x
3269 
    result = getAllAvailableAmazonFbaItemInventory_result()
3270 
    result.read(self._iprot)
3271 
    self._iprot.readMessageEnd()
3272 
    if result.success is not None:
3273 
      return result.success
3274 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAvailableAmazonFbaItemInventory failed: unknown result");
3275 
 
17990 kshitij.so 3276 
  def updateItemAvailabilityForItemIds(self, itemIds):
3277 
    """
3278 
    Parameters:
3279 
     - itemIds
3280 
    """
3281 
    self.send_updateItemAvailabilityForItemIds(itemIds)
3282 
    return self.recv_updateItemAvailabilityForItemIds()
12363 kshitij.so 3283 
 
17990 kshitij.so 3284 
  def send_updateItemAvailabilityForItemIds(self, itemIds):
3285 
    self._oprot.writeMessageBegin('updateItemAvailabilityForItemIds', TMessageType.CALL, self._seqid)
3286 
    args = updateItemAvailabilityForItemIds_args()
3287 
    args.itemIds = itemIds
3288 
    args.write(self._oprot)
3289 
    self._oprot.writeMessageEnd()
3290 
    self._oprot.trans.flush()
3291 
 
3292 
  def recv_updateItemAvailabilityForItemIds(self, ):
3293 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3294 
    if mtype == TMessageType.EXCEPTION:
3295 
      x = TApplicationException()
3296 
      x.read(self._iprot)
3297 
      self._iprot.readMessageEnd()
3298 
      raise x
3299 
    result = updateItemAvailabilityForItemIds_result()
3300 
    result.read(self._iprot)
3301 
    self._iprot.readMessageEnd()
3302 
    if result.success is not None:
3303 
      return result.success
3304 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemAvailabilityForItemIds failed: unknown result");
3305 
 
19247 kshitij.so 3306 
  def addVendorItemPricingInBulk(self, vendorItemPricingList):
3307 
    """
3308 
    Parameters:
3309 
     - vendorItemPricingList
3310 
    """
3311 
    self.send_addVendorItemPricingInBulk(vendorItemPricingList)
3312 
    return self.recv_addVendorItemPricingInBulk()
17990 kshitij.so 3313 
 
19247 kshitij.so 3314 
  def send_addVendorItemPricingInBulk(self, vendorItemPricingList):
3315 
    self._oprot.writeMessageBegin('addVendorItemPricingInBulk', TMessageType.CALL, self._seqid)
3316 
    args = addVendorItemPricingInBulk_args()
3317 
    args.vendorItemPricingList = vendorItemPricingList
3318 
    args.write(self._oprot)
3319 
    self._oprot.writeMessageEnd()
3320 
    self._oprot.trans.flush()
3321 
 
3322 
  def recv_addVendorItemPricingInBulk(self, ):
3323 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3324 
    if mtype == TMessageType.EXCEPTION:
3325 
      x = TApplicationException()
3326 
      x.read(self._iprot)
3327 
      self._iprot.readMessageEnd()
3328 
      raise x
3329 
    result = addVendorItemPricingInBulk_result()
3330 
    result.read(self._iprot)
3331 
    self._iprot.readMessageEnd()
3332 
    if result.success is not None:
3333 
      return result.success
3334 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addVendorItemPricingInBulk failed: unknown result");
3335 
 
3336 
  def addInventoryInBulk(self, bulkInventoryList):
3337 
    """
3338 
    Parameters:
3339 
     - bulkInventoryList
3340 
    """
3341 
    self.send_addInventoryInBulk(bulkInventoryList)
3342 
    self.recv_addInventoryInBulk()
3343 
 
3344 
  def send_addInventoryInBulk(self, bulkInventoryList):
3345 
    self._oprot.writeMessageBegin('addInventoryInBulk', TMessageType.CALL, self._seqid)
3346 
    args = addInventoryInBulk_args()
3347 
    args.bulkInventoryList = bulkInventoryList
3348 
    args.write(self._oprot)
3349 
    self._oprot.writeMessageEnd()
3350 
    self._oprot.trans.flush()
3351 
 
3352 
  def recv_addInventoryInBulk(self, ):
3353 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3354 
    if mtype == TMessageType.EXCEPTION:
3355 
      x = TApplicationException()
3356 
      x.read(self._iprot)
3357 
      self._iprot.readMessageEnd()
3358 
      raise x
3359 
    result = addInventoryInBulk_result()
3360 
    result.read(self._iprot)
3361 
    self._iprot.readMessageEnd()
3362 
    if result.cex is not None:
3363 
      raise result.cex
3364 
    return
3365 
 
22717 amit.gupta 3366 
  def getFofoAvailability(self, itemIds):
3367 
    """
3368 
    Parameters:
3369 
     - itemIds
3370 
    """
3371 
    self.send_getFofoAvailability(itemIds)
3372 
    return self.recv_getFofoAvailability()
3373 
 
3374 
  def send_getFofoAvailability(self, itemIds):
3375 
    self._oprot.writeMessageBegin('getFofoAvailability', TMessageType.CALL, self._seqid)
3376 
    args = getFofoAvailability_args()
3377 
    args.itemIds = itemIds
3378 
    args.write(self._oprot)
3379 
    self._oprot.writeMessageEnd()
3380 
    self._oprot.trans.flush()
3381 
 
3382 
  def recv_getFofoAvailability(self, ):
3383 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3384 
    if mtype == TMessageType.EXCEPTION:
3385 
      x = TApplicationException()
3386 
      x.read(self._iprot)
3387 
      self._iprot.readMessageEnd()
3388 
      raise x
3389 
    result = getFofoAvailability_result()
3390 
    result.read(self._iprot)
3391 
    self._iprot.readMessageEnd()
3392 
    if result.success is not None:
3393 
      return result.success
3394 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFofoAvailability failed: unknown result");
3395 
 
22721 amit.gupta 3396 
  def getFofoFulFillmentWarehouseMap(self, itemIds):
3397 
    """
3398 
    Parameters:
3399 
     - itemIds
3400 
    """
3401 
    self.send_getFofoFulFillmentWarehouseMap(itemIds)
3402 
    return self.recv_getFofoFulFillmentWarehouseMap()
3403 
 
3404 
  def send_getFofoFulFillmentWarehouseMap(self, itemIds):
3405 
    self._oprot.writeMessageBegin('getFofoFulFillmentWarehouseMap', TMessageType.CALL, self._seqid)
3406 
    args = getFofoFulFillmentWarehouseMap_args()
3407 
    args.itemIds = itemIds
3408 
    args.write(self._oprot)
3409 
    self._oprot.writeMessageEnd()
3410 
    self._oprot.trans.flush()
3411 
 
3412 
  def recv_getFofoFulFillmentWarehouseMap(self, ):
3413 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3414 
    if mtype == TMessageType.EXCEPTION:
3415 
      x = TApplicationException()
3416 
      x.read(self._iprot)
3417 
      self._iprot.readMessageEnd()
3418 
      raise x
3419 
    result = getFofoFulFillmentWarehouseMap_result()
3420 
    result.read(self._iprot)
3421 
    self._iprot.readMessageEnd()
3422 
    if result.success is not None:
3423 
      return result.success
3424 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFofoFulFillmentWarehouseMap failed: unknown result");
3425 
 
19413 amit.gupta 3426 
  def getItemLocationAvailabilityCache(self, itemLocations):
3427 
    """
3428 
    Parameters:
3429 
     - itemLocations
3430 
    """
3431 
    self.send_getItemLocationAvailabilityCache(itemLocations)
3432 
    return self.recv_getItemLocationAvailabilityCache()
19247 kshitij.so 3433 
 
19413 amit.gupta 3434 
  def send_getItemLocationAvailabilityCache(self, itemLocations):
3435 
    self._oprot.writeMessageBegin('getItemLocationAvailabilityCache', TMessageType.CALL, self._seqid)
3436 
    args = getItemLocationAvailabilityCache_args()
3437 
    args.itemLocations = itemLocations
3438 
    args.write(self._oprot)
3439 
    self._oprot.writeMessageEnd()
3440 
    self._oprot.trans.flush()
3441 
 
3442 
  def recv_getItemLocationAvailabilityCache(self, ):
3443 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3444 
    if mtype == TMessageType.EXCEPTION:
3445 
      x = TApplicationException()
3446 
      x.read(self._iprot)
3447 
      self._iprot.readMessageEnd()
3448 
      raise x
3449 
    result = getItemLocationAvailabilityCache_result()
3450 
    result.read(self._iprot)
3451 
    self._iprot.readMessageEnd()
3452 
    if result.success is not None:
3453 
      return result.success
3454 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemLocationAvailabilityCache failed: unknown result");
3455 
 
3456 
  def getItemLocationAvailabilityCacheByItemId(self, itemIds):
3457 
    """
3458 
    Parameters:
3459 
     - itemIds
3460 
    """
3461 
    self.send_getItemLocationAvailabilityCacheByItemId(itemIds)
3462 
    return self.recv_getItemLocationAvailabilityCacheByItemId()
3463 
 
3464 
  def send_getItemLocationAvailabilityCacheByItemId(self, itemIds):
3465 
    self._oprot.writeMessageBegin('getItemLocationAvailabilityCacheByItemId', TMessageType.CALL, self._seqid)
3466 
    args = getItemLocationAvailabilityCacheByItemId_args()
3467 
    args.itemIds = itemIds
3468 
    args.write(self._oprot)
3469 
    self._oprot.writeMessageEnd()
3470 
    self._oprot.trans.flush()
3471 
 
3472 
  def recv_getItemLocationAvailabilityCacheByItemId(self, ):
3473 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3474 
    if mtype == TMessageType.EXCEPTION:
3475 
      x = TApplicationException()
3476 
      x.read(self._iprot)
3477 
      self._iprot.readMessageEnd()
3478 
      raise x
3479 
    result = getItemLocationAvailabilityCacheByItemId_result()
3480 
    result.read(self._iprot)
3481 
    self._iprot.readMessageEnd()
3482 
    if result.success is not None:
3483 
      return result.success
3484 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemLocationAvailabilityCacheByItemId failed: unknown result");
3485 
 
19416 amit.gupta 3486 
  def getItemPincodeAvailability(self, itempricing, pincode):
19413 amit.gupta 3487 
    """
3488 
    Parameters:
19416 amit.gupta 3489 
     - itempricing
19413 amit.gupta 3490 
     - pincode
3491 
    """
19416 amit.gupta 3492 
    self.send_getItemPincodeAvailability(itempricing, pincode)
19413 amit.gupta 3493 
    return self.recv_getItemPincodeAvailability()
3494 
 
19416 amit.gupta 3495 
  def send_getItemPincodeAvailability(self, itempricing, pincode):
19413 amit.gupta 3496 
    self._oprot.writeMessageBegin('getItemPincodeAvailability', TMessageType.CALL, self._seqid)
3497 
    args = getItemPincodeAvailability_args()
19416 amit.gupta 3498 
    args.itempricing = itempricing
19413 amit.gupta 3499 
    args.pincode = pincode
3500 
    args.write(self._oprot)
3501 
    self._oprot.writeMessageEnd()
3502 
    self._oprot.trans.flush()
3503 
 
3504 
  def recv_getItemPincodeAvailability(self, ):
3505 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3506 
    if mtype == TMessageType.EXCEPTION:
3507 
      x = TApplicationException()
3508 
      x.read(self._iprot)
3509 
      self._iprot.readMessageEnd()
3510 
      raise x
3511 
    result = getItemPincodeAvailability_result()
3512 
    result.read(self._iprot)
3513 
    self._iprot.readMessageEnd()
3514 
    if result.success is not None:
3515 
      return result.success
3516 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPincodeAvailability failed: unknown result");
3517 
 
3518 
 
5944 mandeep.dh 3519 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
3520 
  def __init__(self, handler):
3521 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
3522 
    self._processMap["addWarehouse"] = Processor.process_addWarehouse
3523 
    self._processMap["addVendor"] = Processor.process_addVendor
3524 
    self._processMap["updateInventoryHistory"] = Processor.process_updateInventoryHistory
3525 
    self._processMap["updateInventory"] = Processor.process_updateInventory
3526 
    self._processMap["addInventory"] = Processor.process_addInventory
3527 
    self._processMap["retireWarehouse"] = Processor.process_retireWarehouse
3528 
    self._processMap["getItemInventoryByItemId"] = Processor.process_getItemInventoryByItemId
3529 
    self._processMap["getItemAvailibilityAtWarehouse"] = Processor.process_getItemAvailibilityAtWarehouse
3530 
    self._processMap["getItemAvailabilityAtLocation"] = Processor.process_getItemAvailabilityAtLocation
3531 
    self._processMap["getAllWarehouses"] = Processor.process_getAllWarehouses
3532 
    self._processMap["getWarehouse"] = Processor.process_getWarehouse
3533 
    self._processMap["getAllItemsForWarehouse"] = Processor.process_getAllItemsForWarehouse
5966 rajveer 3534 
    self._processMap["isOrderBillable"] = Processor.process_isOrderBillable
5944 mandeep.dh 3535 
    self._processMap["reserveItemInWarehouse"] = Processor.process_reserveItemInWarehouse
7968 amar.kumar 3536 
    self._processMap["updateReservationForOrder"] = Processor.process_updateReservationForOrder
5944 mandeep.dh 3537 
    self._processMap["reduceReservationCount"] = Processor.process_reduceReservationCount
3538 
    self._processMap["getItemPricing"] = Processor.process_getItemPricing
3539 
    self._processMap["getAllItemPricing"] = Processor.process_getAllItemPricing
3540 
    self._processMap["addVendorItemPricing"] = Processor.process_addVendorItemPricing
3541 
    self._processMap["getVendor"] = Processor.process_getVendor
3542 
    self._processMap["getAllVendors"] = Processor.process_getAllVendors
3543 
    self._processMap["addVendorItemMapping"] = Processor.process_addVendorItemMapping
3544 
    self._processMap["getVendorItemMappings"] = Processor.process_getVendorItemMappings
3545 
    self._processMap["getPendingOrdersInventory"] = Processor.process_getPendingOrdersInventory
3546 
    self._processMap["getWarehouses"] = Processor.process_getWarehouses
3547 
    self._processMap["resetAvailability"] = Processor.process_resetAvailability
3548 
    self._processMap["resetAvailabilityForWarehouse"] = Processor.process_resetAvailabilityForWarehouse
3549 
    self._processMap["getItemKeysToBeProcessed"] = Processor.process_getItemKeysToBeProcessed
3550 
    self._processMap["markMissedInventoryUpdatesAsProcessed"] = Processor.process_markMissedInventoryUpdatesAsProcessed
3551 
    self._processMap["getIgnoredItemKeys"] = Processor.process_getIgnoredItemKeys
3552 
    self._processMap["addBadInventory"] = Processor.process_addBadInventory
3553 
    self._processMap["getShippingLocations"] = Processor.process_getShippingLocations
3554 
    self._processMap["getAllVendorItemMappings"] = Processor.process_getAllVendorItemMappings
3555 
    self._processMap["getInventorySnapshot"] = Processor.process_getInventorySnapshot
3556 
    self._processMap["clearItemAvailabilityCache"] = Processor.process_clearItemAvailabilityCache
3557 
    self._processMap["updateVendorString"] = Processor.process_updateVendorString
6096 amit.gupta 3558 
    self._processMap["clearItemAvailabilityCacheForItem"] = Processor.process_clearItemAvailabilityCacheForItem
6467 amar.kumar 3559 
    self._processMap["getOurWarehouseIdForVendor"] = Processor.process_getOurWarehouseIdForVendor
6484 amar.kumar 3560 
    self._processMap["getItemAvailabilitiesAtOurWarehouses"] = Processor.process_getItemAvailabilitiesAtOurWarehouses
6531 vikram.rag 3561 
    self._processMap["getMonitoredWarehouseForVendors"] = Processor.process_getMonitoredWarehouseForVendors
3562 
    self._processMap["getIgnoredWarehouseidsAndItemids"] = Processor.process_getIgnoredWarehouseidsAndItemids
3563 
    self._processMap["insertItemtoIgnoreInventoryUpdatelist"] = Processor.process_insertItemtoIgnoreInventoryUpdatelist
3564 
    self._processMap["deleteItemFromIgnoredInventoryUpdateList"] = Processor.process_deleteItemFromIgnoredInventoryUpdateList
3565 
    self._processMap["getAllIgnoredInventoryupdateItemsCount"] = Processor.process_getAllIgnoredInventoryupdateItemsCount
3566 
    self._processMap["getIgnoredInventoryUpdateItemids"] = Processor.process_getIgnoredInventoryUpdateItemids
6821 amar.kumar 3567 
    self._processMap["updateItemStockPurchaseParams"] = Processor.process_updateItemStockPurchaseParams
3568 
    self._processMap["getItemStockPurchaseParams"] = Processor.process_getItemStockPurchaseParams
3569 
    self._processMap["addOosStatusForItem"] = Processor.process_addOosStatusForItem
6832 amar.kumar 3570 
    self._processMap["getOosStatusesForXDaysForItem"] = Processor.process_getOosStatusesForXDaysForItem
10126 amar.kumar 3571 
    self._processMap["getOosStatusesForXDays"] = Processor.process_getOosStatusesForXDays
3572 
    self._processMap["getAllVendorItemPricing"] = Processor.process_getAllVendorItemPricing
6857 amar.kumar 3573 
    self._processMap["getNonZeroItemStockPurchaseParams"] = Processor.process_getNonZeroItemStockPurchaseParams
7149 amar.kumar 3574 
    self._processMap["getBillableInventoryAndPendingOrders"] = Processor.process_getBillableInventoryAndPendingOrders
7281 kshitij.so 3575 
    self._processMap["getWarehouseName"] = Processor.process_getWarehouseName
3576 
    self._processMap["getAmazonInventoryForItem"] = Processor.process_getAmazonInventoryForItem
3577 
    self._processMap["getAllAmazonInventory"] = Processor.process_getAllAmazonInventory
3578 
    self._processMap["addOrUpdateAmazonInventoryForItem"] = Processor.process_addOrUpdateAmazonInventoryForItem
7972 amar.kumar 3579 
    self._processMap["getLastNdaySaleForItem"] = Processor.process_getLastNdaySaleForItem
8282 kshitij.so 3580 
    self._processMap["addOrUpdateAmazonFbaInventory"] = Processor.process_addOrUpdateAmazonFbaInventory
8182 amar.kumar 3581 
    self._processMap["addUpdateHoldInventory"] = Processor.process_addUpdateHoldInventory
8282 kshitij.so 3582 
    self._processMap["getAmazonFbaItemInventory"] = Processor.process_getAmazonFbaItemInventory
8363 vikram.rag 3583 
    self._processMap["getAllAmazonFbaItemInventory"] = Processor.process_getAllAmazonFbaItemInventory
3584 
    self._processMap["getOursGoodWarehouseIdsForLocation"] = Processor.process_getOursGoodWarehouseIdsForLocation
8955 vikram.rag 3585 
    self._processMap["getHoldInventoryDetailForItemForWarehouseIdExceptSource"] = Processor.process_getHoldInventoryDetailForItemForWarehouseIdExceptSource
9404 vikram.rag 3586 
    self._processMap["getSnapdealInventoryForItem"] = Processor.process_getSnapdealInventoryForItem
3587 
    self._processMap["addOrUpdateSnapdealInventoryForItem"] = Processor.process_addOrUpdateSnapdealInventoryForItem
3588 
    self._processMap["getNlcForWarehouse"] = Processor.process_getNlcForWarehouse
9640 amar.kumar 3589 
    self._processMap["getHeldInventoryMapForItem"] = Processor.process_getHeldInventoryMapForItem
9482 vikram.rag 3590 
    self._processMap["addOrUpdateAllAmazonFbaInventory"] = Processor.process_addOrUpdateAllAmazonFbaInventory
9495 vikram.rag 3591 
    self._processMap["addOrUpdateAllSnapdealInventory"] = Processor.process_addOrUpdateAllSnapdealInventory
3592 
    self._processMap["getSnapdealInventorySnapshot"] = Processor.process_getSnapdealInventorySnapshot
9761 amar.kumar 3593 
    self._processMap["getHoldInventoryDetails"] = Processor.process_getHoldInventoryDetails
10050 vikram.rag 3594 
    self._processMap["addOrUpdateFlipkartInventorySnapshot"] = Processor.process_addOrUpdateFlipkartInventorySnapshot
3595 
    self._processMap["getFlipkartInventorySnapshot"] = Processor.process_getFlipkartInventorySnapshot
10097 kshitij.so 3596 
    self._processMap["getFlipkartlInventoryForItem"] = Processor.process_getFlipkartlInventoryForItem
10485 vikram.rag 3597 
    self._processMap["getStateMaster"] = Processor.process_getStateMaster
10544 vikram.rag 3598 
    self._processMap["updateSnapdealStockAtEOD"] = Processor.process_updateSnapdealStockAtEOD
3599 
    self._processMap["updateFlipkartStockAtEOD"] = Processor.process_updateFlipkartStockAtEOD
12363 kshitij.so 3600 
    self._processMap["getWanNlcForSource"] = Processor.process_getWanNlcForSource
3601 
    self._processMap["getAllAvailableAmazonFbaItemInventory"] = Processor.process_getAllAvailableAmazonFbaItemInventory
17990 kshitij.so 3602 
    self._processMap["updateItemAvailabilityForItemIds"] = Processor.process_updateItemAvailabilityForItemIds
19247 kshitij.so 3603 
    self._processMap["addVendorItemPricingInBulk"] = Processor.process_addVendorItemPricingInBulk
3604 
    self._processMap["addInventoryInBulk"] = Processor.process_addInventoryInBulk
22717 amit.gupta 3605 
    self._processMap["getFofoAvailability"] = Processor.process_getFofoAvailability
22721 amit.gupta 3606 
    self._processMap["getFofoFulFillmentWarehouseMap"] = Processor.process_getFofoFulFillmentWarehouseMap
19413 amit.gupta 3607 
    self._processMap["getItemLocationAvailabilityCache"] = Processor.process_getItemLocationAvailabilityCache
3608 
    self._processMap["getItemLocationAvailabilityCacheByItemId"] = Processor.process_getItemLocationAvailabilityCacheByItemId
3609 
    self._processMap["getItemPincodeAvailability"] = Processor.process_getItemPincodeAvailability
5944 mandeep.dh 3610 
 
3611 
  def process(self, iprot, oprot):
3612 
    (name, type, seqid) = iprot.readMessageBegin()
3613 
    if name not in self._processMap:
3614 
      iprot.skip(TType.STRUCT)
3615 
      iprot.readMessageEnd()
3616 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3617 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3618 
      x.write(oprot)
3619 
      oprot.writeMessageEnd()
3620 
      oprot.trans.flush()
3621 
      return
3622 
    else:
3623 
      self._processMap[name](self, seqid, iprot, oprot)
3624 
    return True
3625 
 
3626 
  def process_addWarehouse(self, seqid, iprot, oprot):
3627 
    args = addWarehouse_args()
3628 
    args.read(iprot)
3629 
    iprot.readMessageEnd()
3630 
    result = addWarehouse_result()
3631 
    try:
3632 
      result.success = self._handler.addWarehouse(args.warehouse)
3633 
    except InventoryServiceException, cex:
3634 
      result.cex = cex
3635 
    oprot.writeMessageBegin("addWarehouse", TMessageType.REPLY, seqid)
3636 
    result.write(oprot)
3637 
    oprot.writeMessageEnd()
3638 
    oprot.trans.flush()
3639 
 
3640 
  def process_addVendor(self, seqid, iprot, oprot):
3641 
    args = addVendor_args()
3642 
    args.read(iprot)
3643 
    iprot.readMessageEnd()
3644 
    result = addVendor_result()
3645 
    try:
3646 
      result.success = self._handler.addVendor(args.vendor)
3647 
    except InventoryServiceException, cex:
3648 
      result.cex = cex
3649 
    oprot.writeMessageBegin("addVendor", TMessageType.REPLY, seqid)
3650 
    result.write(oprot)
3651 
    oprot.writeMessageEnd()
3652 
    oprot.trans.flush()
3653 
 
3654 
  def process_updateInventoryHistory(self, seqid, iprot, oprot):
3655 
    args = updateInventoryHistory_args()
3656 
    args.read(iprot)
3657 
    iprot.readMessageEnd()
3658 
    result = updateInventoryHistory_result()
3659 
    try:
3660 
      self._handler.updateInventoryHistory(args.warehouse_id, args.timestamp, args.availability)
3661 
    except InventoryServiceException, cex:
3662 
      result.cex = cex
3663 
    oprot.writeMessageBegin("updateInventoryHistory", TMessageType.REPLY, seqid)
3664 
    result.write(oprot)
3665 
    oprot.writeMessageEnd()
3666 
    oprot.trans.flush()
3667 
 
3668 
  def process_updateInventory(self, seqid, iprot, oprot):
3669 
    args = updateInventory_args()
3670 
    args.read(iprot)
3671 
    iprot.readMessageEnd()
3672 
    result = updateInventory_result()
3673 
    try:
3674 
      self._handler.updateInventory(args.warehouse_id, args.timestamp, args.availability)
3675 
    except InventoryServiceException, cex:
3676 
      result.cex = cex
3677 
    oprot.writeMessageBegin("updateInventory", TMessageType.REPLY, seqid)
3678 
    result.write(oprot)
3679 
    oprot.writeMessageEnd()
3680 
    oprot.trans.flush()
3681 
 
3682 
  def process_addInventory(self, seqid, iprot, oprot):
3683 
    args = addInventory_args()
3684 
    args.read(iprot)
3685 
    iprot.readMessageEnd()
3686 
    result = addInventory_result()
3687 
    try:
3688 
      self._handler.addInventory(args.itemId, args.warehouseId, args.quantity)
3689 
    except InventoryServiceException, cex:
3690 
      result.cex = cex
3691 
    oprot.writeMessageBegin("addInventory", TMessageType.REPLY, seqid)
3692 
    result.write(oprot)
3693 
    oprot.writeMessageEnd()
3694 
    oprot.trans.flush()
3695 
 
3696 
  def process_retireWarehouse(self, seqid, iprot, oprot):
3697 
    args = retireWarehouse_args()
3698 
    args.read(iprot)
3699 
    iprot.readMessageEnd()
3700 
    result = retireWarehouse_result()
3701 
    try:
3702 
      self._handler.retireWarehouse(args.warehouse_id)
3703 
    except InventoryServiceException, cex:
3704 
      result.cex = cex
3705 
    oprot.writeMessageBegin("retireWarehouse", TMessageType.REPLY, seqid)
3706 
    result.write(oprot)
3707 
    oprot.writeMessageEnd()
3708 
    oprot.trans.flush()
3709 
 
3710 
  def process_getItemInventoryByItemId(self, seqid, iprot, oprot):
3711 
    args = getItemInventoryByItemId_args()
3712 
    args.read(iprot)
3713 
    iprot.readMessageEnd()
3714 
    result = getItemInventoryByItemId_result()
3715 
    try:
3716 
      result.success = self._handler.getItemInventoryByItemId(args.item_id)
3717 
    except InventoryServiceException, cex:
3718 
      result.cex = cex
3719 
    oprot.writeMessageBegin("getItemInventoryByItemId", TMessageType.REPLY, seqid)
3720 
    result.write(oprot)
3721 
    oprot.writeMessageEnd()
3722 
    oprot.trans.flush()
3723 
 
3724 
  def process_getItemAvailibilityAtWarehouse(self, seqid, iprot, oprot):
3725 
    args = getItemAvailibilityAtWarehouse_args()
3726 
    args.read(iprot)
3727 
    iprot.readMessageEnd()
3728 
    result = getItemAvailibilityAtWarehouse_result()
3729 
    try:
3730 
      result.success = self._handler.getItemAvailibilityAtWarehouse(args.warehouse_id, args.item_id)
3731 
    except InventoryServiceException, cex:
3732 
      result.cex = cex
3733 
    oprot.writeMessageBegin("getItemAvailibilityAtWarehouse", TMessageType.REPLY, seqid)
3734 
    result.write(oprot)
3735 
    oprot.writeMessageEnd()
3736 
    oprot.trans.flush()
3737 
 
3738 
  def process_getItemAvailabilityAtLocation(self, seqid, iprot, oprot):
3739 
    args = getItemAvailabilityAtLocation_args()
3740 
    args.read(iprot)
3741 
    iprot.readMessageEnd()
3742 
    result = getItemAvailabilityAtLocation_result()
3743 
    try:
23446 amit.gupta 3744 
      result.success = self._handler.getItemAvailabilityAtLocation(args.itemId, args.sourceId, args.stateId)
5944 mandeep.dh 3745 
    except InventoryServiceException, isex:
3746 
      result.isex = isex
3747 
    oprot.writeMessageBegin("getItemAvailabilityAtLocation", TMessageType.REPLY, seqid)
3748 
    result.write(oprot)
3749 
    oprot.writeMessageEnd()
3750 
    oprot.trans.flush()
3751 
 
3752 
  def process_getAllWarehouses(self, seqid, iprot, oprot):
3753 
    args = getAllWarehouses_args()
3754 
    args.read(iprot)
3755 
    iprot.readMessageEnd()
3756 
    result = getAllWarehouses_result()
3757 
    try:
3758 
      result.success = self._handler.getAllWarehouses(args.isActive)
3759 
    except InventoryServiceException, cex:
3760 
      result.cex = cex
3761 
    oprot.writeMessageBegin("getAllWarehouses", TMessageType.REPLY, seqid)
3762 
    result.write(oprot)
3763 
    oprot.writeMessageEnd()
3764 
    oprot.trans.flush()
3765 
 
3766 
  def process_getWarehouse(self, seqid, iprot, oprot):
3767 
    args = getWarehouse_args()
3768 
    args.read(iprot)
3769 
    iprot.readMessageEnd()
3770 
    result = getWarehouse_result()
3771 
    try:
3772 
      result.success = self._handler.getWarehouse(args.warehouse_id)
3773 
    except InventoryServiceException, cex:
3774 
      result.cex = cex
3775 
    oprot.writeMessageBegin("getWarehouse", TMessageType.REPLY, seqid)
3776 
    result.write(oprot)
3777 
    oprot.writeMessageEnd()
3778 
    oprot.trans.flush()
3779 
 
3780 
  def process_getAllItemsForWarehouse(self, seqid, iprot, oprot):
3781 
    args = getAllItemsForWarehouse_args()
3782 
    args.read(iprot)
3783 
    iprot.readMessageEnd()
3784 
    result = getAllItemsForWarehouse_result()
3785 
    try:
3786 
      result.success = self._handler.getAllItemsForWarehouse(args.warehouse_id)
3787 
    except InventoryServiceException, cex:
3788 
      result.cex = cex
3789 
    oprot.writeMessageBegin("getAllItemsForWarehouse", TMessageType.REPLY, seqid)
3790 
    result.write(oprot)
3791 
    oprot.writeMessageEnd()
3792 
    oprot.trans.flush()
3793 
 
5966 rajveer 3794 
  def process_isOrderBillable(self, seqid, iprot, oprot):
3795 
    args = isOrderBillable_args()
3796 
    args.read(iprot)
3797 
    iprot.readMessageEnd()
3798 
    result = isOrderBillable_result()
3799 
    result.success = self._handler.isOrderBillable(args.itemId, args.warehouseId, args.sourceId, args.orderId)
3800 
    oprot.writeMessageBegin("isOrderBillable", TMessageType.REPLY, seqid)
3801 
    result.write(oprot)
3802 
    oprot.writeMessageEnd()
3803 
    oprot.trans.flush()
3804 
 
5944 mandeep.dh 3805 
  def process_reserveItemInWarehouse(self, seqid, iprot, oprot):
3806 
    args = reserveItemInWarehouse_args()
3807 
    args.read(iprot)
3808 
    iprot.readMessageEnd()
3809 
    result = reserveItemInWarehouse_result()
3810 
    try:
5966 rajveer 3811 
      result.success = self._handler.reserveItemInWarehouse(args.itemId, args.warehouseId, args.sourceId, args.orderId, args.createdTimestamp, args.promisedShippingTimestamp, args.quantity)
5944 mandeep.dh 3812 
    except InventoryServiceException, cex:
3813 
      result.cex = cex
3814 
    oprot.writeMessageBegin("reserveItemInWarehouse", TMessageType.REPLY, seqid)
3815 
    result.write(oprot)
3816 
    oprot.writeMessageEnd()
3817 
    oprot.trans.flush()
3818 
 
7968 amar.kumar 3819 
  def process_updateReservationForOrder(self, seqid, iprot, oprot):
3820 
    args = updateReservationForOrder_args()
3821 
    args.read(iprot)
3822 
    iprot.readMessageEnd()
3823 
    result = updateReservationForOrder_result()
3824 
    try:
3825 
      result.success = self._handler.updateReservationForOrder(args.itemId, args.warehouseId, args.sourceId, args.orderId, args.createdTimestamp, args.promisedShippingTimestamp, args.quantity)
3826 
    except InventoryServiceException, cex:
3827 
      result.cex = cex
3828 
    oprot.writeMessageBegin("updateReservationForOrder", TMessageType.REPLY, seqid)
3829 
    result.write(oprot)
3830 
    oprot.writeMessageEnd()
3831 
    oprot.trans.flush()
3832 
 
5944 mandeep.dh 3833 
  def process_reduceReservationCount(self, seqid, iprot, oprot):
3834 
    args = reduceReservationCount_args()
3835 
    args.read(iprot)
3836 
    iprot.readMessageEnd()
3837 
    result = reduceReservationCount_result()
3838 
    try:
5966 rajveer 3839 
      result.success = self._handler.reduceReservationCount(args.itemId, args.warehouseId, args.sourceId, args.orderId, args.quantity)
5944 mandeep.dh 3840 
    except InventoryServiceException, cex:
3841 
      result.cex = cex
3842 
    oprot.writeMessageBegin("reduceReservationCount", TMessageType.REPLY, seqid)
3843 
    result.write(oprot)
3844 
    oprot.writeMessageEnd()
3845 
    oprot.trans.flush()
3846 
 
3847 
  def process_getItemPricing(self, seqid, iprot, oprot):
3848 
    args = getItemPricing_args()
3849 
    args.read(iprot)
3850 
    iprot.readMessageEnd()
3851 
    result = getItemPricing_result()
3852 
    try:
3853 
      result.success = self._handler.getItemPricing(args.itemId, args.vendorId)
3854 
    except InventoryServiceException, cex:
3855 
      result.cex = cex
3856 
    oprot.writeMessageBegin("getItemPricing", TMessageType.REPLY, seqid)
3857 
    result.write(oprot)
3858 
    oprot.writeMessageEnd()
3859 
    oprot.trans.flush()
3860 
 
3861 
  def process_getAllItemPricing(self, seqid, iprot, oprot):
3862 
    args = getAllItemPricing_args()
3863 
    args.read(iprot)
3864 
    iprot.readMessageEnd()
3865 
    result = getAllItemPricing_result()
3866 
    try:
3867 
      result.success = self._handler.getAllItemPricing(args.itemId)
3868 
    except InventoryServiceException, cex:
3869 
      result.cex = cex
3870 
    oprot.writeMessageBegin("getAllItemPricing", TMessageType.REPLY, seqid)
3871 
    result.write(oprot)
3872 
    oprot.writeMessageEnd()
3873 
    oprot.trans.flush()
3874 
 
3875 
  def process_addVendorItemPricing(self, seqid, iprot, oprot):
3876 
    args = addVendorItemPricing_args()
3877 
    args.read(iprot)
3878 
    iprot.readMessageEnd()
3879 
    result = addVendorItemPricing_result()
3880 
    try:
3881 
      self._handler.addVendorItemPricing(args.vendorItemPricing)
3882 
    except InventoryServiceException, cex:
3883 
      result.cex = cex
3884 
    oprot.writeMessageBegin("addVendorItemPricing", TMessageType.REPLY, seqid)
3885 
    result.write(oprot)
3886 
    oprot.writeMessageEnd()
3887 
    oprot.trans.flush()
3888 
 
3889 
  def process_getVendor(self, seqid, iprot, oprot):
3890 
    args = getVendor_args()
3891 
    args.read(iprot)
3892 
    iprot.readMessageEnd()
3893 
    result = getVendor_result()
3894 
    result.success = self._handler.getVendor(args.vendorId)
3895 
    oprot.writeMessageBegin("getVendor", TMessageType.REPLY, seqid)
3896 
    result.write(oprot)
3897 
    oprot.writeMessageEnd()
3898 
    oprot.trans.flush()
3899 
 
3900 
  def process_getAllVendors(self, seqid, iprot, oprot):
3901 
    args = getAllVendors_args()
3902 
    args.read(iprot)
3903 
    iprot.readMessageEnd()
3904 
    result = getAllVendors_result()
3905 
    result.success = self._handler.getAllVendors()
3906 
    oprot.writeMessageBegin("getAllVendors", TMessageType.REPLY, seqid)
3907 
    result.write(oprot)
3908 
    oprot.writeMessageEnd()
3909 
    oprot.trans.flush()
3910 
 
3911 
  def process_addVendorItemMapping(self, seqid, iprot, oprot):
3912 
    args = addVendorItemMapping_args()
3913 
    args.read(iprot)
3914 
    iprot.readMessageEnd()
3915 
    result = addVendorItemMapping_result()
3916 
    try:
3917 
      self._handler.addVendorItemMapping(args.key, args.vendorItemMapping)
3918 
    except InventoryServiceException, cex:
3919 
      result.cex = cex
3920 
    oprot.writeMessageBegin("addVendorItemMapping", TMessageType.REPLY, seqid)
3921 
    result.write(oprot)
3922 
    oprot.writeMessageEnd()
3923 
    oprot.trans.flush()
3924 
 
3925 
  def process_getVendorItemMappings(self, seqid, iprot, oprot):
3926 
    args = getVendorItemMappings_args()
3927 
    args.read(iprot)
3928 
    iprot.readMessageEnd()
3929 
    result = getVendorItemMappings_result()
3930 
    try:
3931 
      result.success = self._handler.getVendorItemMappings(args.itemId)
3932 
    except InventoryServiceException, cex:
3933 
      result.cex = cex
3934 
    oprot.writeMessageBegin("getVendorItemMappings", TMessageType.REPLY, seqid)
3935 
    result.write(oprot)
3936 
    oprot.writeMessageEnd()
3937 
    oprot.trans.flush()
3938 
 
3939 
  def process_getPendingOrdersInventory(self, seqid, iprot, oprot):
3940 
    args = getPendingOrdersInventory_args()
3941 
    args.read(iprot)
3942 
    iprot.readMessageEnd()
3943 
    result = getPendingOrdersInventory_result()
3944 
    result.success = self._handler.getPendingOrdersInventory(args.vendorid)
3945 
    oprot.writeMessageBegin("getPendingOrdersInventory", TMessageType.REPLY, seqid)
3946 
    result.write(oprot)
3947 
    oprot.writeMessageEnd()
3948 
    oprot.trans.flush()
3949 
 
3950 
  def process_getWarehouses(self, seqid, iprot, oprot):
3951 
    args = getWarehouses_args()
3952 
    args.read(iprot)
3953 
    iprot.readMessageEnd()
3954 
    result = getWarehouses_result()
3955 
    result.success = self._handler.getWarehouses(args.warehouseType, args.inventoryType, args.vendorId, args.billingWarehouseId, args.shippingWarehouseId)
3956 
    oprot.writeMessageBegin("getWarehouses", TMessageType.REPLY, seqid)
3957 
    result.write(oprot)
3958 
    oprot.writeMessageEnd()
3959 
    oprot.trans.flush()
3960 
 
3961 
  def process_resetAvailability(self, seqid, iprot, oprot):
3962 
    args = resetAvailability_args()
3963 
    args.read(iprot)
3964 
    iprot.readMessageEnd()
3965 
    result = resetAvailability_result()
3966 
    try:
3967 
      self._handler.resetAvailability(args.itemKey, args.vendorId, args.quantity, args.warehouseId)
3968 
    except InventoryServiceException, cex:
3969 
      result.cex = cex
3970 
    oprot.writeMessageBegin("resetAvailability", TMessageType.REPLY, seqid)
3971 
    result.write(oprot)
3972 
    oprot.writeMessageEnd()
3973 
    oprot.trans.flush()
3974 
 
3975 
  def process_resetAvailabilityForWarehouse(self, seqid, iprot, oprot):
3976 
    args = resetAvailabilityForWarehouse_args()
3977 
    args.read(iprot)
3978 
    iprot.readMessageEnd()
3979 
    result = resetAvailabilityForWarehouse_result()
3980 
    try:
3981 
      self._handler.resetAvailabilityForWarehouse(args.warehouseId)
3982 
    except InventoryServiceException, cex:
3983 
      result.cex = cex
3984 
    oprot.writeMessageBegin("resetAvailabilityForWarehouse", TMessageType.REPLY, seqid)
3985 
    result.write(oprot)
3986 
    oprot.writeMessageEnd()
3987 
    oprot.trans.flush()
3988 
 
3989 
  def process_getItemKeysToBeProcessed(self, seqid, iprot, oprot):
3990 
    args = getItemKeysToBeProcessed_args()
3991 
    args.read(iprot)
3992 
    iprot.readMessageEnd()
3993 
    result = getItemKeysToBeProcessed_result()
3994 
    result.success = self._handler.getItemKeysToBeProcessed(args.warehouseId)
3995 
    oprot.writeMessageBegin("getItemKeysToBeProcessed", TMessageType.REPLY, seqid)
3996 
    result.write(oprot)
3997 
    oprot.writeMessageEnd()
3998 
    oprot.trans.flush()
3999 
 
4000 
  def process_markMissedInventoryUpdatesAsProcessed(self, seqid, iprot, oprot):
4001 
    args = markMissedInventoryUpdatesAsProcessed_args()
4002 
    args.read(iprot)
4003 
    iprot.readMessageEnd()
4004 
    result = markMissedInventoryUpdatesAsProcessed_result()
4005 
    self._handler.markMissedInventoryUpdatesAsProcessed(args.itemKey, args.warehouseId)
4006 
    oprot.writeMessageBegin("markMissedInventoryUpdatesAsProcessed", TMessageType.REPLY, seqid)
4007 
    result.write(oprot)
4008 
    oprot.writeMessageEnd()
4009 
    oprot.trans.flush()
4010 
 
4011 
  def process_getIgnoredItemKeys(self, seqid, iprot, oprot):
4012 
    args = getIgnoredItemKeys_args()
4013 
    args.read(iprot)
4014 
    iprot.readMessageEnd()
4015 
    result = getIgnoredItemKeys_result()
4016 
    result.success = self._handler.getIgnoredItemKeys()
4017 
    oprot.writeMessageBegin("getIgnoredItemKeys", TMessageType.REPLY, seqid)
4018 
    result.write(oprot)
4019 
    oprot.writeMessageEnd()
4020 
    oprot.trans.flush()
4021 
 
4022 
  def process_addBadInventory(self, seqid, iprot, oprot):
4023 
    args = addBadInventory_args()
4024 
    args.read(iprot)
4025 
    iprot.readMessageEnd()
4026 
    result = addBadInventory_result()
4027 
    try:
4028 
      self._handler.addBadInventory(args.itemId, args.warehouseId, args.quantity)
4029 
    except InventoryServiceException, cex:
4030 
      result.cex = cex
4031 
    oprot.writeMessageBegin("addBadInventory", TMessageType.REPLY, seqid)
4032 
    result.write(oprot)
4033 
    oprot.writeMessageEnd()
4034 
    oprot.trans.flush()
4035 
 
4036 
  def process_getShippingLocations(self, seqid, iprot, oprot):
4037 
    args = getShippingLocations_args()
4038 
    args.read(iprot)
4039 
    iprot.readMessageEnd()
4040 
    result = getShippingLocations_result()
4041 
    result.success = self._handler.getShippingLocations()
4042 
    oprot.writeMessageBegin("getShippingLocations", TMessageType.REPLY, seqid)
4043 
    result.write(oprot)
4044 
    oprot.writeMessageEnd()
4045 
    oprot.trans.flush()
4046 
 
4047 
  def process_getAllVendorItemMappings(self, seqid, iprot, oprot):
4048 
    args = getAllVendorItemMappings_args()
4049 
    args.read(iprot)
4050 
    iprot.readMessageEnd()
4051 
    result = getAllVendorItemMappings_result()
4052 
    result.success = self._handler.getAllVendorItemMappings()
4053 
    oprot.writeMessageBegin("getAllVendorItemMappings", TMessageType.REPLY, seqid)
4054 
    result.write(oprot)
4055 
    oprot.writeMessageEnd()
4056 
    oprot.trans.flush()
4057 
 
4058 
  def process_getInventorySnapshot(self, seqid, iprot, oprot):
4059 
    args = getInventorySnapshot_args()
4060 
    args.read(iprot)
4061 
    iprot.readMessageEnd()
4062 
    result = getInventorySnapshot_result()
4063 
    result.success = self._handler.getInventorySnapshot(args.warehouseId)
4064 
    oprot.writeMessageBegin("getInventorySnapshot", TMessageType.REPLY, seqid)
4065 
    result.write(oprot)
4066 
    oprot.writeMessageEnd()
4067 
    oprot.trans.flush()
4068 
 
4069 
  def process_clearItemAvailabilityCache(self, seqid, iprot, oprot):
4070 
    args = clearItemAvailabilityCache_args()
4071 
    args.read(iprot)
4072 
    iprot.readMessageEnd()
4073 
    result = clearItemAvailabilityCache_result()
4074 
    self._handler.clearItemAvailabilityCache()
4075 
    oprot.writeMessageBegin("clearItemAvailabilityCache", TMessageType.REPLY, seqid)
4076 
    result.write(oprot)
4077 
    oprot.writeMessageEnd()
4078 
    oprot.trans.flush()
4079 
 
4080 
  def process_updateVendorString(self, seqid, iprot, oprot):
4081 
    args = updateVendorString_args()
4082 
    args.read(iprot)
4083 
    iprot.readMessageEnd()
4084 
    result = updateVendorString_result()
4085 
    self._handler.updateVendorString(args.warehouseId, args.vendorString)
4086 
    oprot.writeMessageBegin("updateVendorString", TMessageType.REPLY, seqid)
4087 
    result.write(oprot)
4088 
    oprot.writeMessageEnd()
4089 
    oprot.trans.flush()
4090 
 
6096 amit.gupta 4091 
  def process_clearItemAvailabilityCacheForItem(self, seqid, iprot, oprot):
4092 
    args = clearItemAvailabilityCacheForItem_args()
4093 
    args.read(iprot)
4094 
    iprot.readMessageEnd()
4095 
    result = clearItemAvailabilityCacheForItem_result()
4096 
    self._handler.clearItemAvailabilityCacheForItem(args.item_id)
4097 
    oprot.writeMessageBegin("clearItemAvailabilityCacheForItem", TMessageType.REPLY, seqid)
4098 
    result.write(oprot)
4099 
    oprot.writeMessageEnd()
4100 
    oprot.trans.flush()
5944 mandeep.dh 4101 
 
6467 amar.kumar 4102 
  def process_getOurWarehouseIdForVendor(self, seqid, iprot, oprot):
4103 
    args = getOurWarehouseIdForVendor_args()
4104 
    args.read(iprot)
4105 
    iprot.readMessageEnd()
4106 
    result = getOurWarehouseIdForVendor_result()
7718 amar.kumar 4107 
    result.success = self._handler.getOurWarehouseIdForVendor(args.vendorId, args.billingWarehouseId)
6467 amar.kumar 4108 
    oprot.writeMessageBegin("getOurWarehouseIdForVendor", TMessageType.REPLY, seqid)
4109 
    result.write(oprot)
4110 
    oprot.writeMessageEnd()
4111 
    oprot.trans.flush()
6096 amit.gupta 4112 
 
6484 amar.kumar 4113 
  def process_getItemAvailabilitiesAtOurWarehouses(self, seqid, iprot, oprot):
4114 
    args = getItemAvailabilitiesAtOurWarehouses_args()
4115 
    args.read(iprot)
4116 
    iprot.readMessageEnd()
4117 
    result = getItemAvailabilitiesAtOurWarehouses_result()
4118 
    result.success = self._handler.getItemAvailabilitiesAtOurWarehouses(args.item_ids)
4119 
    oprot.writeMessageBegin("getItemAvailabilitiesAtOurWarehouses", TMessageType.REPLY, seqid)
4120 
    result.write(oprot)
4121 
    oprot.writeMessageEnd()
4122 
    oprot.trans.flush()
6467 amar.kumar 4123 
 
6531 vikram.rag 4124 
  def process_getMonitoredWarehouseForVendors(self, seqid, iprot, oprot):
4125 
    args = getMonitoredWarehouseForVendors_args()
4126 
    args.read(iprot)
4127 
    iprot.readMessageEnd()
4128 
    result = getMonitoredWarehouseForVendors_result()
4129 
    result.success = self._handler.getMonitoredWarehouseForVendors(args.vendorIds)
4130 
    oprot.writeMessageBegin("getMonitoredWarehouseForVendors", TMessageType.REPLY, seqid)
4131 
    result.write(oprot)
4132 
    oprot.writeMessageEnd()
4133 
    oprot.trans.flush()
6484 amar.kumar 4134 
 
6531 vikram.rag 4135 
  def process_getIgnoredWarehouseidsAndItemids(self, seqid, iprot, oprot):
4136 
    args = getIgnoredWarehouseidsAndItemids_args()
4137 
    args.read(iprot)
4138 
    iprot.readMessageEnd()
4139 
    result = getIgnoredWarehouseidsAndItemids_result()
4140 
    result.success = self._handler.getIgnoredWarehouseidsAndItemids()
4141 
    oprot.writeMessageBegin("getIgnoredWarehouseidsAndItemids", TMessageType.REPLY, seqid)
4142 
    result.write(oprot)
4143 
    oprot.writeMessageEnd()
4144 
    oprot.trans.flush()
4145 
 
4146 
  def process_insertItemtoIgnoreInventoryUpdatelist(self, seqid, iprot, oprot):
4147 
    args = insertItemtoIgnoreInventoryUpdatelist_args()
4148 
    args.read(iprot)
4149 
    iprot.readMessageEnd()
4150 
    result = insertItemtoIgnoreInventoryUpdatelist_result()
4151 
    result.success = self._handler.insertItemtoIgnoreInventoryUpdatelist(args.item_id, args.warehouse_id)
4152 
    oprot.writeMessageBegin("insertItemtoIgnoreInventoryUpdatelist", TMessageType.REPLY, seqid)
4153 
    result.write(oprot)
4154 
    oprot.writeMessageEnd()
4155 
    oprot.trans.flush()
4156 
 
4157 
  def process_deleteItemFromIgnoredInventoryUpdateList(self, seqid, iprot, oprot):
4158 
    args = deleteItemFromIgnoredInventoryUpdateList_args()
4159 
    args.read(iprot)
4160 
    iprot.readMessageEnd()
4161 
    result = deleteItemFromIgnoredInventoryUpdateList_result()
4162 
    result.success = self._handler.deleteItemFromIgnoredInventoryUpdateList(args.item_id, args.warehouse_id)
4163 
    oprot.writeMessageBegin("deleteItemFromIgnoredInventoryUpdateList", TMessageType.REPLY, seqid)
4164 
    result.write(oprot)
4165 
    oprot.writeMessageEnd()
4166 
    oprot.trans.flush()
4167 
 
4168 
  def process_getAllIgnoredInventoryupdateItemsCount(self, seqid, iprot, oprot):
4169 
    args = getAllIgnoredInventoryupdateItemsCount_args()
4170 
    args.read(iprot)
4171 
    iprot.readMessageEnd()
4172 
    result = getAllIgnoredInventoryupdateItemsCount_result()
4173 
    result.success = self._handler.getAllIgnoredInventoryupdateItemsCount()
4174 
    oprot.writeMessageBegin("getAllIgnoredInventoryupdateItemsCount", TMessageType.REPLY, seqid)
4175 
    result.write(oprot)
4176 
    oprot.writeMessageEnd()
4177 
    oprot.trans.flush()
4178 
 
4179 
  def process_getIgnoredInventoryUpdateItemids(self, seqid, iprot, oprot):
4180 
    args = getIgnoredInventoryUpdateItemids_args()
4181 
    args.read(iprot)
4182 
    iprot.readMessageEnd()
4183 
    result = getIgnoredInventoryUpdateItemids_result()
4184 
    result.success = self._handler.getIgnoredInventoryUpdateItemids(args.offset, args.limit)
4185 
    oprot.writeMessageBegin("getIgnoredInventoryUpdateItemids", TMessageType.REPLY, seqid)
4186 
    result.write(oprot)
4187 
    oprot.writeMessageEnd()
4188 
    oprot.trans.flush()
4189 
 
6821 amar.kumar 4190 
  def process_updateItemStockPurchaseParams(self, seqid, iprot, oprot):
4191 
    args = updateItemStockPurchaseParams_args()
4192 
    args.read(iprot)
4193 
    iprot.readMessageEnd()
4194 
    result = updateItemStockPurchaseParams_result()
4195 
    self._handler.updateItemStockPurchaseParams(args.item_id, args.numOfDaysStock, args.minStockLevel)
4196 
    oprot.writeMessageBegin("updateItemStockPurchaseParams", TMessageType.REPLY, seqid)
4197 
    result.write(oprot)
4198 
    oprot.writeMessageEnd()
4199 
    oprot.trans.flush()
6531 vikram.rag 4200 
 
6821 amar.kumar 4201 
  def process_getItemStockPurchaseParams(self, seqid, iprot, oprot):
4202 
    args = getItemStockPurchaseParams_args()
4203 
    args.read(iprot)
4204 
    iprot.readMessageEnd()
4205 
    result = getItemStockPurchaseParams_result()
4206 
    result.success = self._handler.getItemStockPurchaseParams(args.itemId)
4207 
    oprot.writeMessageBegin("getItemStockPurchaseParams", TMessageType.REPLY, seqid)
4208 
    result.write(oprot)
4209 
    oprot.writeMessageEnd()
4210 
    oprot.trans.flush()
4211 
 
4212 
  def process_addOosStatusForItem(self, seqid, iprot, oprot):
4213 
    args = addOosStatusForItem_args()
4214 
    args.read(iprot)
4215 
    iprot.readMessageEnd()
4216 
    result = addOosStatusForItem_result()
4217 
    self._handler.addOosStatusForItem(args.oosStatusMap, args.date)
4218 
    oprot.writeMessageBegin("addOosStatusForItem", TMessageType.REPLY, seqid)
4219 
    result.write(oprot)
4220 
    oprot.writeMessageEnd()
4221 
    oprot.trans.flush()
4222 
 
6832 amar.kumar 4223 
  def process_getOosStatusesForXDaysForItem(self, seqid, iprot, oprot):
4224 
    args = getOosStatusesForXDaysForItem_args()
4225 
    args.read(iprot)
4226 
    iprot.readMessageEnd()
4227 
    result = getOosStatusesForXDaysForItem_result()
9762 amar.kumar 4228 
    result.success = self._handler.getOosStatusesForXDaysForItem(args.itemId, args.sourceId, args.days)
6832 amar.kumar 4229 
    oprot.writeMessageBegin("getOosStatusesForXDaysForItem", TMessageType.REPLY, seqid)
4230 
    result.write(oprot)
4231 
    oprot.writeMessageEnd()
4232 
    oprot.trans.flush()
6821 amar.kumar 4233 
 
10126 amar.kumar 4234 
  def process_getOosStatusesForXDays(self, seqid, iprot, oprot):
4235 
    args = getOosStatusesForXDays_args()
4236 
    args.read(iprot)
4237 
    iprot.readMessageEnd()
4238 
    result = getOosStatusesForXDays_result()
4239 
    result.success = self._handler.getOosStatusesForXDays(args.sourceId, args.days)
4240 
    oprot.writeMessageBegin("getOosStatusesForXDays", TMessageType.REPLY, seqid)
4241 
    result.write(oprot)
4242 
    oprot.writeMessageEnd()
4243 
    oprot.trans.flush()
4244 
 
4245 
  def process_getAllVendorItemPricing(self, seqid, iprot, oprot):
4246 
    args = getAllVendorItemPricing_args()
4247 
    args.read(iprot)
4248 
    iprot.readMessageEnd()
4249 
    result = getAllVendorItemPricing_result()
4250 
    result.success = self._handler.getAllVendorItemPricing(args.itemId, args.vendorId)
4251 
    oprot.writeMessageBegin("getAllVendorItemPricing", TMessageType.REPLY, seqid)
4252 
    result.write(oprot)
4253 
    oprot.writeMessageEnd()
4254 
    oprot.trans.flush()
4255 
 
6857 amar.kumar 4256 
  def process_getNonZeroItemStockPurchaseParams(self, seqid, iprot, oprot):
4257 
    args = getNonZeroItemStockPurchaseParams_args()
4258 
    args.read(iprot)
4259 
    iprot.readMessageEnd()
4260 
    result = getNonZeroItemStockPurchaseParams_result()
4261 
    result.success = self._handler.getNonZeroItemStockPurchaseParams()
4262 
    oprot.writeMessageBegin("getNonZeroItemStockPurchaseParams", TMessageType.REPLY, seqid)
4263 
    result.write(oprot)
4264 
    oprot.writeMessageEnd()
4265 
    oprot.trans.flush()
6832 amar.kumar 4266 
 
7149 amar.kumar 4267 
  def process_getBillableInventoryAndPendingOrders(self, seqid, iprot, oprot):
4268 
    args = getBillableInventoryAndPendingOrders_args()
4269 
    args.read(iprot)
4270 
    iprot.readMessageEnd()
4271 
    result = getBillableInventoryAndPendingOrders_result()
4272 
    result.success = self._handler.getBillableInventoryAndPendingOrders()
4273 
    oprot.writeMessageBegin("getBillableInventoryAndPendingOrders", TMessageType.REPLY, seqid)
4274 
    result.write(oprot)
4275 
    oprot.writeMessageEnd()
4276 
    oprot.trans.flush()
6857 amar.kumar 4277 
 
7281 kshitij.so 4278 
  def process_getWarehouseName(self, seqid, iprot, oprot):
4279 
    args = getWarehouseName_args()
4280 
    args.read(iprot)
4281 
    iprot.readMessageEnd()
4282 
    result = getWarehouseName_result()
4283 
    result.success = self._handler.getWarehouseName(args.warehouse_id)
4284 
    oprot.writeMessageBegin("getWarehouseName", TMessageType.REPLY, seqid)
4285 
    result.write(oprot)
4286 
    oprot.writeMessageEnd()
4287 
    oprot.trans.flush()
7149 amar.kumar 4288 
 
7281 kshitij.so 4289 
  def process_getAmazonInventoryForItem(self, seqid, iprot, oprot):
4290 
    args = getAmazonInventoryForItem_args()
4291 
    args.read(iprot)
4292 
    iprot.readMessageEnd()
4293 
    result = getAmazonInventoryForItem_result()
4294 
    result.success = self._handler.getAmazonInventoryForItem(args.item_id)
4295 
    oprot.writeMessageBegin("getAmazonInventoryForItem", TMessageType.REPLY, seqid)
4296 
    result.write(oprot)
4297 
    oprot.writeMessageEnd()
4298 
    oprot.trans.flush()
4299 
 
4300 
  def process_getAllAmazonInventory(self, seqid, iprot, oprot):
4301 
    args = getAllAmazonInventory_args()
4302 
    args.read(iprot)
4303 
    iprot.readMessageEnd()
4304 
    result = getAllAmazonInventory_result()
4305 
    result.success = self._handler.getAllAmazonInventory()
4306 
    oprot.writeMessageBegin("getAllAmazonInventory", TMessageType.REPLY, seqid)
4307 
    result.write(oprot)
4308 
    oprot.writeMessageEnd()
4309 
    oprot.trans.flush()
4310 
 
4311 
  def process_addOrUpdateAmazonInventoryForItem(self, seqid, iprot, oprot):
4312 
    args = addOrUpdateAmazonInventoryForItem_args()
4313 
    args.read(iprot)
4314 
    iprot.readMessageEnd()
4315 
    result = addOrUpdateAmazonInventoryForItem_result()
10450 vikram.rag 4316 
    self._handler.addOrUpdateAmazonInventoryForItem(args.amazonInventorySnapshot, args.time)
7281 kshitij.so 4317 
    oprot.writeMessageBegin("addOrUpdateAmazonInventoryForItem", TMessageType.REPLY, seqid)
4318 
    result.write(oprot)
4319 
    oprot.writeMessageEnd()
4320 
    oprot.trans.flush()
4321 
 
7972 amar.kumar 4322 
  def process_getLastNdaySaleForItem(self, seqid, iprot, oprot):
4323 
    args = getLastNdaySaleForItem_args()
4324 
    args.read(iprot)
4325 
    iprot.readMessageEnd()
4326 
    result = getLastNdaySaleForItem_result()
4327 
    result.success = self._handler.getLastNdaySaleForItem(args.itemId, args.numberOfDays)
4328 
    oprot.writeMessageBegin("getLastNdaySaleForItem", TMessageType.REPLY, seqid)
4329 
    result.write(oprot)
4330 
    oprot.writeMessageEnd()
4331 
    oprot.trans.flush()
7281 kshitij.so 4332 
 
8282 kshitij.so 4333 
  def process_addOrUpdateAmazonFbaInventory(self, seqid, iprot, oprot):
4334 
    args = addOrUpdateAmazonFbaInventory_args()
4335 
    args.read(iprot)
4336 
    iprot.readMessageEnd()
4337 
    result = addOrUpdateAmazonFbaInventory_result()
4338 
    self._handler.addOrUpdateAmazonFbaInventory(args.amazonfbainventorysnapshot)
4339 
    oprot.writeMessageBegin("addOrUpdateAmazonFbaInventory", TMessageType.REPLY, seqid)
4340 
    result.write(oprot)
4341 
    oprot.writeMessageEnd()
4342 
    oprot.trans.flush()
4343 
 
8182 amar.kumar 4344 
  def process_addUpdateHoldInventory(self, seqid, iprot, oprot):
4345 
    args = addUpdateHoldInventory_args()
4346 
    args.read(iprot)
4347 
    iprot.readMessageEnd()
4348 
    result = addUpdateHoldInventory_result()
9762 amar.kumar 4349 
    try:
4350 
      self._handler.addUpdateHoldInventory(args.itemId, args.warehouseId, args.holdQuantity, args.source)
4351 
    except InventoryServiceException, cex:
4352 
      result.cex = cex
8182 amar.kumar 4353 
    oprot.writeMessageBegin("addUpdateHoldInventory", TMessageType.REPLY, seqid)
4354 
    result.write(oprot)
4355 
    oprot.writeMessageEnd()
4356 
    oprot.trans.flush()
7972 amar.kumar 4357 
 
8282 kshitij.so 4358 
  def process_getAmazonFbaItemInventory(self, seqid, iprot, oprot):
4359 
    args = getAmazonFbaItemInventory_args()
4360 
    args.read(iprot)
4361 
    iprot.readMessageEnd()
4362 
    result = getAmazonFbaItemInventory_result()
4363 
    result.success = self._handler.getAmazonFbaItemInventory(args.itemId)
4364 
    oprot.writeMessageBegin("getAmazonFbaItemInventory", TMessageType.REPLY, seqid)
4365 
    result.write(oprot)
4366 
    oprot.writeMessageEnd()
4367 
    oprot.trans.flush()
8182 amar.kumar 4368 
 
8363 vikram.rag 4369 
  def process_getAllAmazonFbaItemInventory(self, seqid, iprot, oprot):
4370 
    args = getAllAmazonFbaItemInventory_args()
8282 kshitij.so 4371 
    args.read(iprot)
4372 
    iprot.readMessageEnd()
8363 vikram.rag 4373 
    result = getAllAmazonFbaItemInventory_result()
4374 
    result.success = self._handler.getAllAmazonFbaItemInventory()
4375 
    oprot.writeMessageBegin("getAllAmazonFbaItemInventory", TMessageType.REPLY, seqid)
8282 kshitij.so 4376 
    result.write(oprot)
4377 
    oprot.writeMessageEnd()
4378 
    oprot.trans.flush()
4379 
 
8363 vikram.rag 4380 
  def process_getOursGoodWarehouseIdsForLocation(self, seqid, iprot, oprot):
4381 
    args = getOursGoodWarehouseIdsForLocation_args()
4382 
    args.read(iprot)
4383 
    iprot.readMessageEnd()
4384 
    result = getOursGoodWarehouseIdsForLocation_result()
4385 
    result.success = self._handler.getOursGoodWarehouseIdsForLocation(args.state_id)
4386 
    oprot.writeMessageBegin("getOursGoodWarehouseIdsForLocation", TMessageType.REPLY, seqid)
4387 
    result.write(oprot)
4388 
    oprot.writeMessageEnd()
4389 
    oprot.trans.flush()
8282 kshitij.so 4390 
 
8955 vikram.rag 4391 
  def process_getHoldInventoryDetailForItemForWarehouseIdExceptSource(self, seqid, iprot, oprot):
4392 
    args = getHoldInventoryDetailForItemForWarehouseIdExceptSource_args()
4393 
    args.read(iprot)
4394 
    iprot.readMessageEnd()
4395 
    result = getHoldInventoryDetailForItemForWarehouseIdExceptSource_result()
4396 
    result.success = self._handler.getHoldInventoryDetailForItemForWarehouseIdExceptSource(args.id, args.warehouse_id, args.source)
4397 
    oprot.writeMessageBegin("getHoldInventoryDetailForItemForWarehouseIdExceptSource", TMessageType.REPLY, seqid)
4398 
    result.write(oprot)
4399 
    oprot.writeMessageEnd()
4400 
    oprot.trans.flush()
8363 vikram.rag 4401 
 
9404 vikram.rag 4402 
  def process_getSnapdealInventoryForItem(self, seqid, iprot, oprot):
4403 
    args = getSnapdealInventoryForItem_args()
4404 
    args.read(iprot)
4405 
    iprot.readMessageEnd()
4406 
    result = getSnapdealInventoryForItem_result()
4407 
    result.success = self._handler.getSnapdealInventoryForItem(args.item_id)
4408 
    oprot.writeMessageBegin("getSnapdealInventoryForItem", TMessageType.REPLY, seqid)
4409 
    result.write(oprot)
4410 
    oprot.writeMessageEnd()
4411 
    oprot.trans.flush()
8955 vikram.rag 4412 
 
9404 vikram.rag 4413 
  def process_addOrUpdateSnapdealInventoryForItem(self, seqid, iprot, oprot):
4414 
    args = addOrUpdateSnapdealInventoryForItem_args()
4415 
    args.read(iprot)
4416 
    iprot.readMessageEnd()
4417 
    result = addOrUpdateSnapdealInventoryForItem_result()
4418 
    self._handler.addOrUpdateSnapdealInventoryForItem(args.snapdealinventoryitem)
4419 
    oprot.writeMessageBegin("addOrUpdateSnapdealInventoryForItem", TMessageType.REPLY, seqid)
4420 
    result.write(oprot)
4421 
    oprot.writeMessageEnd()
4422 
    oprot.trans.flush()
4423 
 
4424 
  def process_getNlcForWarehouse(self, seqid, iprot, oprot):
4425 
    args = getNlcForWarehouse_args()
4426 
    args.read(iprot)
4427 
    iprot.readMessageEnd()
4428 
    result = getNlcForWarehouse_result()
4429 
    result.success = self._handler.getNlcForWarehouse(args.warehouse_id, args.item_id)
4430 
    oprot.writeMessageBegin("getNlcForWarehouse", TMessageType.REPLY, seqid)
4431 
    result.write(oprot)
4432 
    oprot.writeMessageEnd()
4433 
    oprot.trans.flush()
4434 
 
9640 amar.kumar 4435 
  def process_getHeldInventoryMapForItem(self, seqid, iprot, oprot):
4436 
    args = getHeldInventoryMapForItem_args()
4437 
    args.read(iprot)
4438 
    iprot.readMessageEnd()
4439 
    result = getHeldInventoryMapForItem_result()
4440 
    result.success = self._handler.getHeldInventoryMapForItem(args.item_id, args.warehouse_id)
4441 
    oprot.writeMessageBegin("getHeldInventoryMapForItem", TMessageType.REPLY, seqid)
4442 
    result.write(oprot)
4443 
    oprot.writeMessageEnd()
4444 
    oprot.trans.flush()
4445 
 
9495 vikram.rag 4446 
  def process_addOrUpdateAllAmazonFbaInventory(self, seqid, iprot, oprot):
4447 
    args = addOrUpdateAllAmazonFbaInventory_args()
9456 vikram.rag 4448 
    args.read(iprot)
4449 
    iprot.readMessageEnd()
9495 vikram.rag 4450 
    result = addOrUpdateAllAmazonFbaInventory_result()
4451 
    self._handler.addOrUpdateAllAmazonFbaInventory(args.allamazonfbainventorysnapshot)
4452 
    oprot.writeMessageBegin("addOrUpdateAllAmazonFbaInventory", TMessageType.REPLY, seqid)
9456 vikram.rag 4453 
    result.write(oprot)
4454 
    oprot.writeMessageEnd()
4455 
    oprot.trans.flush()
9404 vikram.rag 4456 
 
9495 vikram.rag 4457 
  def process_addOrUpdateAllSnapdealInventory(self, seqid, iprot, oprot):
4458 
    args = addOrUpdateAllSnapdealInventory_args()
9482 vikram.rag 4459 
    args.read(iprot)
4460 
    iprot.readMessageEnd()
9495 vikram.rag 4461 
    result = addOrUpdateAllSnapdealInventory_result()
4462 
    self._handler.addOrUpdateAllSnapdealInventory(args.allsnapdealinventorysnapshot)
4463 
    oprot.writeMessageBegin("addOrUpdateAllSnapdealInventory", TMessageType.REPLY, seqid)
9482 vikram.rag 4464 
    result.write(oprot)
4465 
    oprot.writeMessageEnd()
4466 
    oprot.trans.flush()
9456 vikram.rag 4467 
 
9495 vikram.rag 4468 
  def process_getSnapdealInventorySnapshot(self, seqid, iprot, oprot):
4469 
    args = getSnapdealInventorySnapshot_args()
4470 
    args.read(iprot)
4471 
    iprot.readMessageEnd()
4472 
    result = getSnapdealInventorySnapshot_result()
4473 
    result.success = self._handler.getSnapdealInventorySnapshot()
4474 
    oprot.writeMessageBegin("getSnapdealInventorySnapshot", TMessageType.REPLY, seqid)
4475 
    result.write(oprot)
4476 
    oprot.writeMessageEnd()
4477 
    oprot.trans.flush()
9482 vikram.rag 4478 
 
9761 amar.kumar 4479 
  def process_getHoldInventoryDetails(self, seqid, iprot, oprot):
4480 
    args = getHoldInventoryDetails_args()
4481 
    args.read(iprot)
4482 
    iprot.readMessageEnd()
4483 
    result = getHoldInventoryDetails_result()
4484 
    result.success = self._handler.getHoldInventoryDetails(args.itemId, args.warehouseId, args.source)
4485 
    oprot.writeMessageBegin("getHoldInventoryDetails", TMessageType.REPLY, seqid)
4486 
    result.write(oprot)
4487 
    oprot.writeMessageEnd()
4488 
    oprot.trans.flush()
9495 vikram.rag 4489 
 
10050 vikram.rag 4490 
  def process_addOrUpdateFlipkartInventorySnapshot(self, seqid, iprot, oprot):
4491 
    args = addOrUpdateFlipkartInventorySnapshot_args()
4492 
    args.read(iprot)
4493 
    iprot.readMessageEnd()
4494 
    result = addOrUpdateFlipkartInventorySnapshot_result()
10450 vikram.rag 4495 
    self._handler.addOrUpdateFlipkartInventorySnapshot(args.flipkartInventorySnapshot, args.time)
10050 vikram.rag 4496 
    oprot.writeMessageBegin("addOrUpdateFlipkartInventorySnapshot", TMessageType.REPLY, seqid)
4497 
    result.write(oprot)
4498 
    oprot.writeMessageEnd()
4499 
    oprot.trans.flush()
9761 amar.kumar 4500 
 
10050 vikram.rag 4501 
  def process_getFlipkartInventorySnapshot(self, seqid, iprot, oprot):
4502 
    args = getFlipkartInventorySnapshot_args()
4503 
    args.read(iprot)
4504 
    iprot.readMessageEnd()
4505 
    result = getFlipkartInventorySnapshot_result()
4506 
    result.success = self._handler.getFlipkartInventorySnapshot()
4507 
    oprot.writeMessageBegin("getFlipkartInventorySnapshot", TMessageType.REPLY, seqid)
4508 
    result.write(oprot)
4509 
    oprot.writeMessageEnd()
4510 
    oprot.trans.flush()
4511 
 
10097 kshitij.so 4512 
  def process_getFlipkartlInventoryForItem(self, seqid, iprot, oprot):
4513 
    args = getFlipkartlInventoryForItem_args()
4514 
    args.read(iprot)
4515 
    iprot.readMessageEnd()
4516 
    result = getFlipkartlInventoryForItem_result()
4517 
    result.success = self._handler.getFlipkartlInventoryForItem(args.item_id)
4518 
    oprot.writeMessageBegin("getFlipkartlInventoryForItem", TMessageType.REPLY, seqid)
4519 
    result.write(oprot)
4520 
    oprot.writeMessageEnd()
4521 
    oprot.trans.flush()
10050 vikram.rag 4522 
 
10485 vikram.rag 4523 
  def process_getStateMaster(self, seqid, iprot, oprot):
4524 
    args = getStateMaster_args()
4525 
    args.read(iprot)
4526 
    iprot.readMessageEnd()
4527 
    result = getStateMaster_result()
4528 
    result.success = self._handler.getStateMaster()
4529 
    oprot.writeMessageBegin("getStateMaster", TMessageType.REPLY, seqid)
4530 
    result.write(oprot)
4531 
    oprot.writeMessageEnd()
4532 
    oprot.trans.flush()
10097 kshitij.so 4533 
 
10544 vikram.rag 4534 
  def process_updateSnapdealStockAtEOD(self, seqid, iprot, oprot):
4535 
    args = updateSnapdealStockAtEOD_args()
4536 
    args.read(iprot)
4537 
    iprot.readMessageEnd()
4538 
    result = updateSnapdealStockAtEOD_result()
4539 
    self._handler.updateSnapdealStockAtEOD(args.allsnapdealstock)
4540 
    oprot.writeMessageBegin("updateSnapdealStockAtEOD", TMessageType.REPLY, seqid)
4541 
    result.write(oprot)
4542 
    oprot.writeMessageEnd()
4543 
    oprot.trans.flush()
10485 vikram.rag 4544 
 
10544 vikram.rag 4545 
  def process_updateFlipkartStockAtEOD(self, seqid, iprot, oprot):
4546 
    args = updateFlipkartStockAtEOD_args()
4547 
    args.read(iprot)
4548 
    iprot.readMessageEnd()
4549 
    result = updateFlipkartStockAtEOD_result()
4550 
    self._handler.updateFlipkartStockAtEOD(args.allflipkartstock)
4551 
    oprot.writeMessageBegin("updateFlipkartStockAtEOD", TMessageType.REPLY, seqid)
4552 
    result.write(oprot)
4553 
    oprot.writeMessageEnd()
4554 
    oprot.trans.flush()
4555 
 
12363 kshitij.so 4556 
  def process_getWanNlcForSource(self, seqid, iprot, oprot):
4557 
    args = getWanNlcForSource_args()
4558 
    args.read(iprot)
4559 
    iprot.readMessageEnd()
4560 
    result = getWanNlcForSource_result()
4561 
    result.success = self._handler.getWanNlcForSource(args.item_id, args.source)
4562 
    oprot.writeMessageBegin("getWanNlcForSource", TMessageType.REPLY, seqid)
4563 
    result.write(oprot)
4564 
    oprot.writeMessageEnd()
4565 
    oprot.trans.flush()
10544 vikram.rag 4566 
 
12363 kshitij.so 4567 
  def process_getAllAvailableAmazonFbaItemInventory(self, seqid, iprot, oprot):
4568 
    args = getAllAvailableAmazonFbaItemInventory_args()
4569 
    args.read(iprot)
4570 
    iprot.readMessageEnd()
4571 
    result = getAllAvailableAmazonFbaItemInventory_result()
4572 
    result.success = self._handler.getAllAvailableAmazonFbaItemInventory()
4573 
    oprot.writeMessageBegin("getAllAvailableAmazonFbaItemInventory", TMessageType.REPLY, seqid)
4574 
    result.write(oprot)
4575 
    oprot.writeMessageEnd()
4576 
    oprot.trans.flush()
4577 
 
17990 kshitij.so 4578 
  def process_updateItemAvailabilityForItemIds(self, seqid, iprot, oprot):
4579 
    args = updateItemAvailabilityForItemIds_args()
4580 
    args.read(iprot)
4581 
    iprot.readMessageEnd()
4582 
    result = updateItemAvailabilityForItemIds_result()
4583 
    result.success = self._handler.updateItemAvailabilityForItemIds(args.itemIds)
4584 
    oprot.writeMessageBegin("updateItemAvailabilityForItemIds", TMessageType.REPLY, seqid)
4585 
    result.write(oprot)
4586 
    oprot.writeMessageEnd()
4587 
    oprot.trans.flush()
12363 kshitij.so 4588 
 
19247 kshitij.so 4589 
  def process_addVendorItemPricingInBulk(self, seqid, iprot, oprot):
4590 
    args = addVendorItemPricingInBulk_args()
4591 
    args.read(iprot)
4592 
    iprot.readMessageEnd()
4593 
    result = addVendorItemPricingInBulk_result()
4594 
    result.success = self._handler.addVendorItemPricingInBulk(args.vendorItemPricingList)
4595 
    oprot.writeMessageBegin("addVendorItemPricingInBulk", TMessageType.REPLY, seqid)
4596 
    result.write(oprot)
4597 
    oprot.writeMessageEnd()
4598 
    oprot.trans.flush()
17990 kshitij.so 4599 
 
19247 kshitij.so 4600 
  def process_addInventoryInBulk(self, seqid, iprot, oprot):
4601 
    args = addInventoryInBulk_args()
4602 
    args.read(iprot)
4603 
    iprot.readMessageEnd()
4604 
    result = addInventoryInBulk_result()
4605 
    try:
4606 
      self._handler.addInventoryInBulk(args.bulkInventoryList)
4607 
    except InventoryServiceException, cex:
4608 
      result.cex = cex
4609 
    oprot.writeMessageBegin("addInventoryInBulk", TMessageType.REPLY, seqid)
4610 
    result.write(oprot)
4611 
    oprot.writeMessageEnd()
4612 
    oprot.trans.flush()
4613 
 
22717 amit.gupta 4614 
  def process_getFofoAvailability(self, seqid, iprot, oprot):
4615 
    args = getFofoAvailability_args()
4616 
    args.read(iprot)
4617 
    iprot.readMessageEnd()
4618 
    result = getFofoAvailability_result()
4619 
    result.success = self._handler.getFofoAvailability(args.itemIds)
4620 
    oprot.writeMessageBegin("getFofoAvailability", TMessageType.REPLY, seqid)
4621 
    result.write(oprot)
4622 
    oprot.writeMessageEnd()
4623 
    oprot.trans.flush()
4624 
 
22721 amit.gupta 4625 
  def process_getFofoFulFillmentWarehouseMap(self, seqid, iprot, oprot):
4626 
    args = getFofoFulFillmentWarehouseMap_args()
4627 
    args.read(iprot)
4628 
    iprot.readMessageEnd()
4629 
    result = getFofoFulFillmentWarehouseMap_result()
4630 
    result.success = self._handler.getFofoFulFillmentWarehouseMap(args.itemIds)
4631 
    oprot.writeMessageBegin("getFofoFulFillmentWarehouseMap", TMessageType.REPLY, seqid)
4632 
    result.write(oprot)
4633 
    oprot.writeMessageEnd()
4634 
    oprot.trans.flush()
4635 
 
19413 amit.gupta 4636 
  def process_getItemLocationAvailabilityCache(self, seqid, iprot, oprot):
4637 
    args = getItemLocationAvailabilityCache_args()
4638 
    args.read(iprot)
4639 
    iprot.readMessageEnd()
4640 
    result = getItemLocationAvailabilityCache_result()
4641 
    result.success = self._handler.getItemLocationAvailabilityCache(args.itemLocations)
4642 
    oprot.writeMessageBegin("getItemLocationAvailabilityCache", TMessageType.REPLY, seqid)
4643 
    result.write(oprot)
4644 
    oprot.writeMessageEnd()
4645 
    oprot.trans.flush()
19247 kshitij.so 4646 
 
19413 amit.gupta 4647 
  def process_getItemLocationAvailabilityCacheByItemId(self, seqid, iprot, oprot):
4648 
    args = getItemLocationAvailabilityCacheByItemId_args()
4649 
    args.read(iprot)
4650 
    iprot.readMessageEnd()
4651 
    result = getItemLocationAvailabilityCacheByItemId_result()
4652 
    result.success = self._handler.getItemLocationAvailabilityCacheByItemId(args.itemIds)
4653 
    oprot.writeMessageBegin("getItemLocationAvailabilityCacheByItemId", TMessageType.REPLY, seqid)
4654 
    result.write(oprot)
4655 
    oprot.writeMessageEnd()
4656 
    oprot.trans.flush()
4657 
 
4658 
  def process_getItemPincodeAvailability(self, seqid, iprot, oprot):
4659 
    args = getItemPincodeAvailability_args()
4660 
    args.read(iprot)
4661 
    iprot.readMessageEnd()
4662 
    result = getItemPincodeAvailability_result()
19416 amit.gupta 4663 
    result.success = self._handler.getItemPincodeAvailability(args.itempricing, args.pincode)
19413 amit.gupta 4664 
    oprot.writeMessageBegin("getItemPincodeAvailability", TMessageType.REPLY, seqid)
4665 
    result.write(oprot)
4666 
    oprot.writeMessageEnd()
4667 
    oprot.trans.flush()
4668 
 
4669 
 
5944 mandeep.dh 4670 
# HELPER FUNCTIONS AND STRUCTURES
4671 
 
4672 
class addWarehouse_args:
4673 
  """
4674 
  Attributes:
4675 
   - warehouse
4676 
  """
4677 
 
4678 
  thrift_spec = (
4679 
    None, # 0
4680 
    (1, TType.STRUCT, 'warehouse', (Warehouse, Warehouse.thrift_spec), None, ), # 1
4681 
  )
4682 
 
4683 
  def __init__(self, warehouse=None,):
4684 
    self.warehouse = warehouse
4685 
 
4686 
  def read(self, iprot):
4687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4689 
      return
4690 
    iprot.readStructBegin()
4691 
    while True:
4692 
      (fname, ftype, fid) = iprot.readFieldBegin()
4693 
      if ftype == TType.STOP:
4694 
        break
4695 
      if fid == 1:
4696 
        if ftype == TType.STRUCT:
4697 
          self.warehouse = Warehouse()
4698 
          self.warehouse.read(iprot)
4699 
        else:
4700 
          iprot.skip(ftype)
4701 
      else:
4702 
        iprot.skip(ftype)
4703 
      iprot.readFieldEnd()
4704 
    iprot.readStructEnd()
4705 
 
4706 
  def write(self, oprot):
4707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4709 
      return
4710 
    oprot.writeStructBegin('addWarehouse_args')
4711 
    if self.warehouse is not None:
4712 
      oprot.writeFieldBegin('warehouse', TType.STRUCT, 1)
4713 
      self.warehouse.write(oprot)
4714 
      oprot.writeFieldEnd()
4715 
    oprot.writeFieldStop()
4716 
    oprot.writeStructEnd()
4717 
 
4718 
  def validate(self):
4719 
    return
4720 
 
4721 
 
4722 
  def __repr__(self):
4723 
    L = ['%s=%r' % (key, value)
4724 
      for key, value in self.__dict__.iteritems()]
4725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4726 
 
4727 
  def __eq__(self, other):
4728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4729 
 
4730 
  def __ne__(self, other):
4731 
    return not (self == other)
4732 
 
4733 
class addWarehouse_result:
4734 
  """
4735 
  Attributes:
4736 
   - success
4737 
   - cex
4738 
  """
4739 
 
4740 
  thrift_spec = (
4741 
    (0, TType.I64, 'success', None, None, ), # 0
4742 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
4743 
  )
4744 
 
4745 
  def __init__(self, success=None, cex=None,):
4746 
    self.success = success
4747 
    self.cex = cex
4748 
 
4749 
  def read(self, iprot):
4750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4752 
      return
4753 
    iprot.readStructBegin()
4754 
    while True:
4755 
      (fname, ftype, fid) = iprot.readFieldBegin()
4756 
      if ftype == TType.STOP:
4757 
        break
4758 
      if fid == 0:
4759 
        if ftype == TType.I64:
4760 
          self.success = iprot.readI64();
4761 
        else:
4762 
          iprot.skip(ftype)
4763 
      elif fid == 1:
4764 
        if ftype == TType.STRUCT:
4765 
          self.cex = InventoryServiceException()
4766 
          self.cex.read(iprot)
4767 
        else:
4768 
          iprot.skip(ftype)
4769 
      else:
4770 
        iprot.skip(ftype)
4771 
      iprot.readFieldEnd()
4772 
    iprot.readStructEnd()
4773 
 
4774 
  def write(self, oprot):
4775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4777 
      return
4778 
    oprot.writeStructBegin('addWarehouse_result')
4779 
    if self.success is not None:
4780 
      oprot.writeFieldBegin('success', TType.I64, 0)
4781 
      oprot.writeI64(self.success)
4782 
      oprot.writeFieldEnd()
4783 
    if self.cex is not None:
4784 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
4785 
      self.cex.write(oprot)
4786 
      oprot.writeFieldEnd()
4787 
    oprot.writeFieldStop()
4788 
    oprot.writeStructEnd()
4789 
 
4790 
  def validate(self):
4791 
    return
4792 
 
4793 
 
4794 
  def __repr__(self):
4795 
    L = ['%s=%r' % (key, value)
4796 
      for key, value in self.__dict__.iteritems()]
4797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4798 
 
4799 
  def __eq__(self, other):
4800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4801 
 
4802 
  def __ne__(self, other):
4803 
    return not (self == other)
4804 
 
4805 
class addVendor_args:
4806 
  """
4807 
  Attributes:
4808 
   - vendor
4809 
  """
4810 
 
4811 
  thrift_spec = (
4812 
    None, # 0
4813 
    (1, TType.STRUCT, 'vendor', (Vendor, Vendor.thrift_spec), None, ), # 1
4814 
  )
4815 
 
4816 
  def __init__(self, vendor=None,):
4817 
    self.vendor = vendor
4818 
 
4819 
  def read(self, iprot):
4820 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4821 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4822 
      return
4823 
    iprot.readStructBegin()
4824 
    while True:
4825 
      (fname, ftype, fid) = iprot.readFieldBegin()
4826 
      if ftype == TType.STOP:
4827 
        break
4828 
      if fid == 1:
4829 
        if ftype == TType.STRUCT:
4830 
          self.vendor = Vendor()
4831 
          self.vendor.read(iprot)
4832 
        else:
4833 
          iprot.skip(ftype)
4834 
      else:
4835 
        iprot.skip(ftype)
4836 
      iprot.readFieldEnd()
4837 
    iprot.readStructEnd()
4838 
 
4839 
  def write(self, oprot):
4840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4842 
      return
4843 
    oprot.writeStructBegin('addVendor_args')
4844 
    if self.vendor is not None:
4845 
      oprot.writeFieldBegin('vendor', TType.STRUCT, 1)
4846 
      self.vendor.write(oprot)
4847 
      oprot.writeFieldEnd()
4848 
    oprot.writeFieldStop()
4849 
    oprot.writeStructEnd()
4850 
 
4851 
  def validate(self):
4852 
    return
4853 
 
4854 
 
4855 
  def __repr__(self):
4856 
    L = ['%s=%r' % (key, value)
4857 
      for key, value in self.__dict__.iteritems()]
4858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4859 
 
4860 
  def __eq__(self, other):
4861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4862 
 
4863 
  def __ne__(self, other):
4864 
    return not (self == other)
4865 
 
4866 
class addVendor_result:
4867 
  """
4868 
  Attributes:
4869 
   - success
4870 
   - cex
4871 
  """
4872 
 
4873 
  thrift_spec = (
4874 
    (0, TType.I64, 'success', None, None, ), # 0
4875 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
4876 
  )
4877 
 
4878 
  def __init__(self, success=None, cex=None,):
4879 
    self.success = success
4880 
    self.cex = cex
4881 
 
4882 
  def read(self, iprot):
4883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4885 
      return
4886 
    iprot.readStructBegin()
4887 
    while True:
4888 
      (fname, ftype, fid) = iprot.readFieldBegin()
4889 
      if ftype == TType.STOP:
4890 
        break
4891 
      if fid == 0:
4892 
        if ftype == TType.I64:
4893 
          self.success = iprot.readI64();
4894 
        else:
4895 
          iprot.skip(ftype)
4896 
      elif fid == 1:
4897 
        if ftype == TType.STRUCT:
4898 
          self.cex = InventoryServiceException()
4899 
          self.cex.read(iprot)
4900 
        else:
4901 
          iprot.skip(ftype)
4902 
      else:
4903 
        iprot.skip(ftype)
4904 
      iprot.readFieldEnd()
4905 
    iprot.readStructEnd()
4906 
 
4907 
  def write(self, oprot):
4908 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4909 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4910 
      return
4911 
    oprot.writeStructBegin('addVendor_result')
4912 
    if self.success is not None:
4913 
      oprot.writeFieldBegin('success', TType.I64, 0)
4914 
      oprot.writeI64(self.success)
4915 
      oprot.writeFieldEnd()
4916 
    if self.cex is not None:
4917 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
4918 
      self.cex.write(oprot)
4919 
      oprot.writeFieldEnd()
4920 
    oprot.writeFieldStop()
4921 
    oprot.writeStructEnd()
4922 
 
4923 
  def validate(self):
4924 
    return
4925 
 
4926 
 
4927 
  def __repr__(self):
4928 
    L = ['%s=%r' % (key, value)
4929 
      for key, value in self.__dict__.iteritems()]
4930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4931 
 
4932 
  def __eq__(self, other):
4933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4934 
 
4935 
  def __ne__(self, other):
4936 
    return not (self == other)
4937 
 
4938 
class updateInventoryHistory_args:
4939 
  """
4940 
  Attributes:
4941 
   - warehouse_id
4942 
   - timestamp
4943 
   - availability
4944 
  """
4945 
 
4946 
  thrift_spec = (
4947 
    None, # 0
4948 
    (1, TType.I64, 'warehouse_id', None, None, ), # 1
4949 
    (2, TType.STRING, 'timestamp', None, None, ), # 2
4950 
    (3, TType.MAP, 'availability', (TType.STRING,None,TType.I64,None), None, ), # 3
4951 
  )
4952 
 
4953 
  def __init__(self, warehouse_id=None, timestamp=None, availability=None,):
4954 
    self.warehouse_id = warehouse_id
4955 
    self.timestamp = timestamp
4956 
    self.availability = availability
4957 
 
4958 
  def read(self, iprot):
4959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4961 
      return
4962 
    iprot.readStructBegin()
4963 
    while True:
4964 
      (fname, ftype, fid) = iprot.readFieldBegin()
4965 
      if ftype == TType.STOP:
4966 
        break
4967 
      if fid == 1:
4968 
        if ftype == TType.I64:
4969 
          self.warehouse_id = iprot.readI64();
4970 
        else:
4971 
          iprot.skip(ftype)
4972 
      elif fid == 2:
4973 
        if ftype == TType.STRING:
4974 
          self.timestamp = iprot.readString();
4975 
        else:
4976 
          iprot.skip(ftype)
4977 
      elif fid == 3:
4978 
        if ftype == TType.MAP:
4979 
          self.availability = {}
8182 amar.kumar 4980 
          (_ktype28, _vtype29, _size27 ) = iprot.readMapBegin()
4981 
          for _i31 in xrange(_size27):
4982 
            _key32 = iprot.readString();
4983 
            _val33 = iprot.readI64();
4984 
            self.availability[_key32] = _val33
5944 mandeep.dh 4985 
          iprot.readMapEnd()
4986 
        else:
4987 
          iprot.skip(ftype)
4988 
      else:
4989 
        iprot.skip(ftype)
4990 
      iprot.readFieldEnd()
4991 
    iprot.readStructEnd()
4992 
 
4993 
  def write(self, oprot):
4994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4996 
      return
4997 
    oprot.writeStructBegin('updateInventoryHistory_args')
4998 
    if self.warehouse_id is not None:
4999 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 1)
5000 
      oprot.writeI64(self.warehouse_id)
5001 
      oprot.writeFieldEnd()
5002 
    if self.timestamp is not None:
5003 
      oprot.writeFieldBegin('timestamp', TType.STRING, 2)
5004 
      oprot.writeString(self.timestamp)
5005 
      oprot.writeFieldEnd()
5006 
    if self.availability is not None:
5007 
      oprot.writeFieldBegin('availability', TType.MAP, 3)
5008 
      oprot.writeMapBegin(TType.STRING, TType.I64, len(self.availability))
8182 amar.kumar 5009 
      for kiter34,viter35 in self.availability.items():
5010 
        oprot.writeString(kiter34)
5011 
        oprot.writeI64(viter35)
5944 mandeep.dh 5012 
      oprot.writeMapEnd()
5013 
      oprot.writeFieldEnd()
5014 
    oprot.writeFieldStop()
5015 
    oprot.writeStructEnd()
5016 
 
5017 
  def validate(self):
5018 
    return
5019 
 
5020 
 
5021 
  def __repr__(self):
5022 
    L = ['%s=%r' % (key, value)
5023 
      for key, value in self.__dict__.iteritems()]
5024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5025 
 
5026 
  def __eq__(self, other):
5027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5028 
 
5029 
  def __ne__(self, other):
5030 
    return not (self == other)
5031 
 
5032 
class updateInventoryHistory_result:
5033 
  """
5034 
  Attributes:
5035 
   - cex
5036 
  """
5037 
 
5038 
  thrift_spec = (
5039 
    None, # 0
5040 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
5041 
  )
5042 
 
5043 
  def __init__(self, cex=None,):
5044 
    self.cex = cex
5045 
 
5046 
  def read(self, iprot):
5047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5049 
      return
5050 
    iprot.readStructBegin()
5051 
    while True:
5052 
      (fname, ftype, fid) = iprot.readFieldBegin()
5053 
      if ftype == TType.STOP:
5054 
        break
5055 
      if fid == 1:
5056 
        if ftype == TType.STRUCT:
5057 
          self.cex = InventoryServiceException()
5058 
          self.cex.read(iprot)
5059 
        else:
5060 
          iprot.skip(ftype)
5061 
      else:
5062 
        iprot.skip(ftype)
5063 
      iprot.readFieldEnd()
5064 
    iprot.readStructEnd()
5065 
 
5066 
  def write(self, oprot):
5067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5069 
      return
5070 
    oprot.writeStructBegin('updateInventoryHistory_result')
5071 
    if self.cex is not None:
5072 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5073 
      self.cex.write(oprot)
5074 
      oprot.writeFieldEnd()
5075 
    oprot.writeFieldStop()
5076 
    oprot.writeStructEnd()
5077 
 
5078 
  def validate(self):
5079 
    return
5080 
 
5081 
 
5082 
  def __repr__(self):
5083 
    L = ['%s=%r' % (key, value)
5084 
      for key, value in self.__dict__.iteritems()]
5085 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5086 
 
5087 
  def __eq__(self, other):
5088 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5089 
 
5090 
  def __ne__(self, other):
5091 
    return not (self == other)
5092 
 
5093 
class updateInventory_args:
5094 
  """
5095 
  Attributes:
5096 
   - warehouse_id
5097 
   - timestamp
5098 
   - availability
5099 
  """
5100 
 
5101 
  thrift_spec = (
5102 
    None, # 0
5103 
    (1, TType.I64, 'warehouse_id', None, None, ), # 1
5104 
    (2, TType.STRING, 'timestamp', None, None, ), # 2
5105 
    (3, TType.MAP, 'availability', (TType.STRING,None,TType.I64,None), None, ), # 3
5106 
  )
5107 
 
5108 
  def __init__(self, warehouse_id=None, timestamp=None, availability=None,):
5109 
    self.warehouse_id = warehouse_id
5110 
    self.timestamp = timestamp
5111 
    self.availability = availability
5112 
 
5113 
  def read(self, iprot):
5114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5116 
      return
5117 
    iprot.readStructBegin()
5118 
    while True:
5119 
      (fname, ftype, fid) = iprot.readFieldBegin()
5120 
      if ftype == TType.STOP:
5121 
        break
5122 
      if fid == 1:
5123 
        if ftype == TType.I64:
5124 
          self.warehouse_id = iprot.readI64();
5125 
        else:
5126 
          iprot.skip(ftype)
5127 
      elif fid == 2:
5128 
        if ftype == TType.STRING:
5129 
          self.timestamp = iprot.readString();
5130 
        else:
5131 
          iprot.skip(ftype)
5132 
      elif fid == 3:
5133 
        if ftype == TType.MAP:
5134 
          self.availability = {}
8182 amar.kumar 5135 
          (_ktype37, _vtype38, _size36 ) = iprot.readMapBegin()
5136 
          for _i40 in xrange(_size36):
5137 
            _key41 = iprot.readString();
5138 
            _val42 = iprot.readI64();
5139 
            self.availability[_key41] = _val42
5944 mandeep.dh 5140 
          iprot.readMapEnd()
5141 
        else:
5142 
          iprot.skip(ftype)
5143 
      else:
5144 
        iprot.skip(ftype)
5145 
      iprot.readFieldEnd()
5146 
    iprot.readStructEnd()
5147 
 
5148 
  def write(self, oprot):
5149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5151 
      return
5152 
    oprot.writeStructBegin('updateInventory_args')
5153 
    if self.warehouse_id is not None:
5154 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 1)
5155 
      oprot.writeI64(self.warehouse_id)
5156 
      oprot.writeFieldEnd()
5157 
    if self.timestamp is not None:
5158 
      oprot.writeFieldBegin('timestamp', TType.STRING, 2)
5159 
      oprot.writeString(self.timestamp)
5160 
      oprot.writeFieldEnd()
5161 
    if self.availability is not None:
5162 
      oprot.writeFieldBegin('availability', TType.MAP, 3)
5163 
      oprot.writeMapBegin(TType.STRING, TType.I64, len(self.availability))
8182 amar.kumar 5164 
      for kiter43,viter44 in self.availability.items():
5165 
        oprot.writeString(kiter43)
5166 
        oprot.writeI64(viter44)
5944 mandeep.dh 5167 
      oprot.writeMapEnd()
5168 
      oprot.writeFieldEnd()
5169 
    oprot.writeFieldStop()
5170 
    oprot.writeStructEnd()
5171 
 
5172 
  def validate(self):
5173 
    return
5174 
 
5175 
 
5176 
  def __repr__(self):
5177 
    L = ['%s=%r' % (key, value)
5178 
      for key, value in self.__dict__.iteritems()]
5179 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5180 
 
5181 
  def __eq__(self, other):
5182 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5183 
 
5184 
  def __ne__(self, other):
5185 
    return not (self == other)
5186 
 
5187 
class updateInventory_result:
5188 
  """
5189 
  Attributes:
5190 
   - cex
5191 
  """
5192 
 
5193 
  thrift_spec = (
5194 
    None, # 0
5195 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
5196 
  )
5197 
 
5198 
  def __init__(self, cex=None,):
5199 
    self.cex = cex
5200 
 
5201 
  def read(self, iprot):
5202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5204 
      return
5205 
    iprot.readStructBegin()
5206 
    while True:
5207 
      (fname, ftype, fid) = iprot.readFieldBegin()
5208 
      if ftype == TType.STOP:
5209 
        break
5210 
      if fid == 1:
5211 
        if ftype == TType.STRUCT:
5212 
          self.cex = InventoryServiceException()
5213 
          self.cex.read(iprot)
5214 
        else:
5215 
          iprot.skip(ftype)
5216 
      else:
5217 
        iprot.skip(ftype)
5218 
      iprot.readFieldEnd()
5219 
    iprot.readStructEnd()
5220 
 
5221 
  def write(self, oprot):
5222 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5223 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5224 
      return
5225 
    oprot.writeStructBegin('updateInventory_result')
5226 
    if self.cex is not None:
5227 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5228 
      self.cex.write(oprot)
5229 
      oprot.writeFieldEnd()
5230 
    oprot.writeFieldStop()
5231 
    oprot.writeStructEnd()
5232 
 
5233 
  def validate(self):
5234 
    return
5235 
 
5236 
 
5237 
  def __repr__(self):
5238 
    L = ['%s=%r' % (key, value)
5239 
      for key, value in self.__dict__.iteritems()]
5240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5241 
 
5242 
  def __eq__(self, other):
5243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5244 
 
5245 
  def __ne__(self, other):
5246 
    return not (self == other)
5247 
 
5248 
class addInventory_args:
5249 
  """
5250 
  Attributes:
5251 
   - itemId
5252 
   - warehouseId
5253 
   - quantity
5254 
  """
5255 
 
5256 
  thrift_spec = (
5257 
    None, # 0
5258 
    (1, TType.I64, 'itemId', None, None, ), # 1
5259 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
5260 
    (3, TType.I64, 'quantity', None, None, ), # 3
5261 
  )
5262 
 
5263 
  def __init__(self, itemId=None, warehouseId=None, quantity=None,):
5264 
    self.itemId = itemId
5265 
    self.warehouseId = warehouseId
5266 
    self.quantity = quantity
5267 
 
5268 
  def read(self, iprot):
5269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5271 
      return
5272 
    iprot.readStructBegin()
5273 
    while True:
5274 
      (fname, ftype, fid) = iprot.readFieldBegin()
5275 
      if ftype == TType.STOP:
5276 
        break
5277 
      if fid == 1:
5278 
        if ftype == TType.I64:
5279 
          self.itemId = iprot.readI64();
5280 
        else:
5281 
          iprot.skip(ftype)
5282 
      elif fid == 2:
5283 
        if ftype == TType.I64:
5284 
          self.warehouseId = iprot.readI64();
5285 
        else:
5286 
          iprot.skip(ftype)
5287 
      elif fid == 3:
5288 
        if ftype == TType.I64:
5289 
          self.quantity = iprot.readI64();
5290 
        else:
5291 
          iprot.skip(ftype)
5292 
      else:
5293 
        iprot.skip(ftype)
5294 
      iprot.readFieldEnd()
5295 
    iprot.readStructEnd()
5296 
 
5297 
  def write(self, oprot):
5298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5300 
      return
5301 
    oprot.writeStructBegin('addInventory_args')
5302 
    if self.itemId is not None:
5303 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5304 
      oprot.writeI64(self.itemId)
5305 
      oprot.writeFieldEnd()
5306 
    if self.warehouseId is not None:
5307 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
5308 
      oprot.writeI64(self.warehouseId)
5309 
      oprot.writeFieldEnd()
5310 
    if self.quantity is not None:
5311 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
5312 
      oprot.writeI64(self.quantity)
5313 
      oprot.writeFieldEnd()
5314 
    oprot.writeFieldStop()
5315 
    oprot.writeStructEnd()
5316 
 
5317 
  def validate(self):
5318 
    return
5319 
 
5320 
 
5321 
  def __repr__(self):
5322 
    L = ['%s=%r' % (key, value)
5323 
      for key, value in self.__dict__.iteritems()]
5324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5325 
 
5326 
  def __eq__(self, other):
5327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5328 
 
5329 
  def __ne__(self, other):
5330 
    return not (self == other)
5331 
 
5332 
class addInventory_result:
5333 
  """
5334 
  Attributes:
5335 
   - cex
5336 
  """
5337 
 
5338 
  thrift_spec = (
5339 
    None, # 0
5340 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
5341 
  )
5342 
 
5343 
  def __init__(self, cex=None,):
5344 
    self.cex = cex
5345 
 
5346 
  def read(self, iprot):
5347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5349 
      return
5350 
    iprot.readStructBegin()
5351 
    while True:
5352 
      (fname, ftype, fid) = iprot.readFieldBegin()
5353 
      if ftype == TType.STOP:
5354 
        break
5355 
      if fid == 1:
5356 
        if ftype == TType.STRUCT:
5357 
          self.cex = InventoryServiceException()
5358 
          self.cex.read(iprot)
5359 
        else:
5360 
          iprot.skip(ftype)
5361 
      else:
5362 
        iprot.skip(ftype)
5363 
      iprot.readFieldEnd()
5364 
    iprot.readStructEnd()
5365 
 
5366 
  def write(self, oprot):
5367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5369 
      return
5370 
    oprot.writeStructBegin('addInventory_result')
5371 
    if self.cex is not None:
5372 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5373 
      self.cex.write(oprot)
5374 
      oprot.writeFieldEnd()
5375 
    oprot.writeFieldStop()
5376 
    oprot.writeStructEnd()
5377 
 
5378 
  def validate(self):
5379 
    return
5380 
 
5381 
 
5382 
  def __repr__(self):
5383 
    L = ['%s=%r' % (key, value)
5384 
      for key, value in self.__dict__.iteritems()]
5385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5386 
 
5387 
  def __eq__(self, other):
5388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5389 
 
5390 
  def __ne__(self, other):
5391 
    return not (self == other)
5392 
 
5393 
class retireWarehouse_args:
5394 
  """
5395 
  Attributes:
5396 
   - warehouse_id
5397 
  """
5398 
 
5399 
  thrift_spec = (
5400 
    None, # 0
5401 
    (1, TType.I64, 'warehouse_id', None, None, ), # 1
5402 
  )
5403 
 
5404 
  def __init__(self, warehouse_id=None,):
5405 
    self.warehouse_id = warehouse_id
5406 
 
5407 
  def read(self, iprot):
5408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5410 
      return
5411 
    iprot.readStructBegin()
5412 
    while True:
5413 
      (fname, ftype, fid) = iprot.readFieldBegin()
5414 
      if ftype == TType.STOP:
5415 
        break
5416 
      if fid == 1:
5417 
        if ftype == TType.I64:
5418 
          self.warehouse_id = iprot.readI64();
5419 
        else:
5420 
          iprot.skip(ftype)
5421 
      else:
5422 
        iprot.skip(ftype)
5423 
      iprot.readFieldEnd()
5424 
    iprot.readStructEnd()
5425 
 
5426 
  def write(self, oprot):
5427 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5428 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5429 
      return
5430 
    oprot.writeStructBegin('retireWarehouse_args')
5431 
    if self.warehouse_id is not None:
5432 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 1)
5433 
      oprot.writeI64(self.warehouse_id)
5434 
      oprot.writeFieldEnd()
5435 
    oprot.writeFieldStop()
5436 
    oprot.writeStructEnd()
5437 
 
5438 
  def validate(self):
5439 
    return
5440 
 
5441 
 
5442 
  def __repr__(self):
5443 
    L = ['%s=%r' % (key, value)
5444 
      for key, value in self.__dict__.iteritems()]
5445 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5446 
 
5447 
  def __eq__(self, other):
5448 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5449 
 
5450 
  def __ne__(self, other):
5451 
    return not (self == other)
5452 
 
5453 
class retireWarehouse_result:
5454 
  """
5455 
  Attributes:
5456 
   - cex
5457 
  """
5458 
 
5459 
  thrift_spec = (
5460 
    None, # 0
5461 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
5462 
  )
5463 
 
5464 
  def __init__(self, cex=None,):
5465 
    self.cex = cex
5466 
 
5467 
  def read(self, iprot):
5468 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5469 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5470 
      return
5471 
    iprot.readStructBegin()
5472 
    while True:
5473 
      (fname, ftype, fid) = iprot.readFieldBegin()
5474 
      if ftype == TType.STOP:
5475 
        break
5476 
      if fid == 1:
5477 
        if ftype == TType.STRUCT:
5478 
          self.cex = InventoryServiceException()
5479 
          self.cex.read(iprot)
5480 
        else:
5481 
          iprot.skip(ftype)
5482 
      else:
5483 
        iprot.skip(ftype)
5484 
      iprot.readFieldEnd()
5485 
    iprot.readStructEnd()
5486 
 
5487 
  def write(self, oprot):
5488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5490 
      return
5491 
    oprot.writeStructBegin('retireWarehouse_result')
5492 
    if self.cex is not None:
5493 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5494 
      self.cex.write(oprot)
5495 
      oprot.writeFieldEnd()
5496 
    oprot.writeFieldStop()
5497 
    oprot.writeStructEnd()
5498 
 
5499 
  def validate(self):
5500 
    return
5501 
 
5502 
 
5503 
  def __repr__(self):
5504 
    L = ['%s=%r' % (key, value)
5505 
      for key, value in self.__dict__.iteritems()]
5506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5507 
 
5508 
  def __eq__(self, other):
5509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5510 
 
5511 
  def __ne__(self, other):
5512 
    return not (self == other)
5513 
 
5514 
class getItemInventoryByItemId_args:
5515 
  """
5516 
  Attributes:
5517 
   - item_id
5518 
  """
5519 
 
5520 
  thrift_spec = (
5521 
    None, # 0
5522 
    (1, TType.I64, 'item_id', None, None, ), # 1
5523 
  )
5524 
 
5525 
  def __init__(self, item_id=None,):
5526 
    self.item_id = item_id
5527 
 
5528 
  def read(self, iprot):
5529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5531 
      return
5532 
    iprot.readStructBegin()
5533 
    while True:
5534 
      (fname, ftype, fid) = iprot.readFieldBegin()
5535 
      if ftype == TType.STOP:
5536 
        break
5537 
      if fid == 1:
5538 
        if ftype == TType.I64:
5539 
          self.item_id = iprot.readI64();
5540 
        else:
5541 
          iprot.skip(ftype)
5542 
      else:
5543 
        iprot.skip(ftype)
5544 
      iprot.readFieldEnd()
5545 
    iprot.readStructEnd()
5546 
 
5547 
  def write(self, oprot):
5548 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5549 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5550 
      return
5551 
    oprot.writeStructBegin('getItemInventoryByItemId_args')
5552 
    if self.item_id is not None:
5553 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
5554 
      oprot.writeI64(self.item_id)
5555 
      oprot.writeFieldEnd()
5556 
    oprot.writeFieldStop()
5557 
    oprot.writeStructEnd()
5558 
 
5559 
  def validate(self):
5560 
    return
5561 
 
5562 
 
5563 
  def __repr__(self):
5564 
    L = ['%s=%r' % (key, value)
5565 
      for key, value in self.__dict__.iteritems()]
5566 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5567 
 
5568 
  def __eq__(self, other):
5569 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5570 
 
5571 
  def __ne__(self, other):
5572 
    return not (self == other)
5573 
 
5574 
class getItemInventoryByItemId_result:
5575 
  """
5576 
  Attributes:
5577 
   - success
5578 
   - cex
5579 
  """
5580 
 
5581 
  thrift_spec = (
5582 
    (0, TType.STRUCT, 'success', (ItemInventory, ItemInventory.thrift_spec), None, ), # 0
5583 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
5584 
  )
5585 
 
5586 
  def __init__(self, success=None, cex=None,):
5587 
    self.success = success
5588 
    self.cex = cex
5589 
 
5590 
  def read(self, iprot):
5591 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5592 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5593 
      return
5594 
    iprot.readStructBegin()
5595 
    while True:
5596 
      (fname, ftype, fid) = iprot.readFieldBegin()
5597 
      if ftype == TType.STOP:
5598 
        break
5599 
      if fid == 0:
5600 
        if ftype == TType.STRUCT:
5601 
          self.success = ItemInventory()
5602 
          self.success.read(iprot)
5603 
        else:
5604 
          iprot.skip(ftype)
5605 
      elif fid == 1:
5606 
        if ftype == TType.STRUCT:
5607 
          self.cex = InventoryServiceException()
5608 
          self.cex.read(iprot)
5609 
        else:
5610 
          iprot.skip(ftype)
5611 
      else:
5612 
        iprot.skip(ftype)
5613 
      iprot.readFieldEnd()
5614 
    iprot.readStructEnd()
5615 
 
5616 
  def write(self, oprot):
5617 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5618 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5619 
      return
5620 
    oprot.writeStructBegin('getItemInventoryByItemId_result')
5621 
    if self.success is not None:
5622 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5623 
      self.success.write(oprot)
5624 
      oprot.writeFieldEnd()
5625 
    if self.cex is not None:
5626 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5627 
      self.cex.write(oprot)
5628 
      oprot.writeFieldEnd()
5629 
    oprot.writeFieldStop()
5630 
    oprot.writeStructEnd()
5631 
 
5632 
  def validate(self):
5633 
    return
5634 
 
5635 
 
5636 
  def __repr__(self):
5637 
    L = ['%s=%r' % (key, value)
5638 
      for key, value in self.__dict__.iteritems()]
5639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5640 
 
5641 
  def __eq__(self, other):
5642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5643 
 
5644 
  def __ne__(self, other):
5645 
    return not (self == other)
5646 
 
5647 
class getItemAvailibilityAtWarehouse_args:
5648 
  """
5649 
  Attributes:
5650 
   - warehouse_id
5651 
   - item_id
5652 
  """
5653 
 
5654 
  thrift_spec = (
5655 
    None, # 0
5656 
    (1, TType.I64, 'warehouse_id', None, None, ), # 1
5657 
    (2, TType.I64, 'item_id', None, None, ), # 2
5658 
  )
5659 
 
5660 
  def __init__(self, warehouse_id=None, item_id=None,):
5661 
    self.warehouse_id = warehouse_id
5662 
    self.item_id = item_id
5663 
 
5664 
  def read(self, iprot):
5665 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5666 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5667 
      return
5668 
    iprot.readStructBegin()
5669 
    while True:
5670 
      (fname, ftype, fid) = iprot.readFieldBegin()
5671 
      if ftype == TType.STOP:
5672 
        break
5673 
      if fid == 1:
5674 
        if ftype == TType.I64:
5675 
          self.warehouse_id = iprot.readI64();
5676 
        else:
5677 
          iprot.skip(ftype)
5678 
      elif fid == 2:
5679 
        if ftype == TType.I64:
5680 
          self.item_id = iprot.readI64();
5681 
        else:
5682 
          iprot.skip(ftype)
5683 
      else:
5684 
        iprot.skip(ftype)
5685 
      iprot.readFieldEnd()
5686 
    iprot.readStructEnd()
5687 
 
5688 
  def write(self, oprot):
5689 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5690 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5691 
      return
5692 
    oprot.writeStructBegin('getItemAvailibilityAtWarehouse_args')
5693 
    if self.warehouse_id is not None:
5694 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 1)
5695 
      oprot.writeI64(self.warehouse_id)
5696 
      oprot.writeFieldEnd()
5697 
    if self.item_id is not None:
5698 
      oprot.writeFieldBegin('item_id', TType.I64, 2)
5699 
      oprot.writeI64(self.item_id)
5700 
      oprot.writeFieldEnd()
5701 
    oprot.writeFieldStop()
5702 
    oprot.writeStructEnd()
5703 
 
5704 
  def validate(self):
5705 
    return
5706 
 
5707 
 
5708 
  def __repr__(self):
5709 
    L = ['%s=%r' % (key, value)
5710 
      for key, value in self.__dict__.iteritems()]
5711 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5712 
 
5713 
  def __eq__(self, other):
5714 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5715 
 
5716 
  def __ne__(self, other):
5717 
    return not (self == other)
5718 
 
5719 
class getItemAvailibilityAtWarehouse_result:
5720 
  """
5721 
  Attributes:
5722 
   - success
5723 
   - cex
5724 
  """
5725 
 
5726 
  thrift_spec = (
5727 
    (0, TType.I64, 'success', None, None, ), # 0
5728 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
5729 
  )
5730 
 
5731 
  def __init__(self, success=None, cex=None,):
5732 
    self.success = success
5733 
    self.cex = cex
5734 
 
5735 
  def read(self, iprot):
5736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5738 
      return
5739 
    iprot.readStructBegin()
5740 
    while True:
5741 
      (fname, ftype, fid) = iprot.readFieldBegin()
5742 
      if ftype == TType.STOP:
5743 
        break
5744 
      if fid == 0:
5745 
        if ftype == TType.I64:
5746 
          self.success = iprot.readI64();
5747 
        else:
5748 
          iprot.skip(ftype)
5749 
      elif fid == 1:
5750 
        if ftype == TType.STRUCT:
5751 
          self.cex = InventoryServiceException()
5752 
          self.cex.read(iprot)
5753 
        else:
5754 
          iprot.skip(ftype)
5755 
      else:
5756 
        iprot.skip(ftype)
5757 
      iprot.readFieldEnd()
5758 
    iprot.readStructEnd()
5759 
 
5760 
  def write(self, oprot):
5761 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5762 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5763 
      return
5764 
    oprot.writeStructBegin('getItemAvailibilityAtWarehouse_result')
5765 
    if self.success is not None:
5766 
      oprot.writeFieldBegin('success', TType.I64, 0)
5767 
      oprot.writeI64(self.success)
5768 
      oprot.writeFieldEnd()
5769 
    if self.cex is not None:
5770 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5771 
      self.cex.write(oprot)
5772 
      oprot.writeFieldEnd()
5773 
    oprot.writeFieldStop()
5774 
    oprot.writeStructEnd()
5775 
 
5776 
  def validate(self):
5777 
    return
5778 
 
5779 
 
5780 
  def __repr__(self):
5781 
    L = ['%s=%r' % (key, value)
5782 
      for key, value in self.__dict__.iteritems()]
5783 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5784 
 
5785 
  def __eq__(self, other):
5786 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5787 
 
5788 
  def __ne__(self, other):
5789 
    return not (self == other)
5790 
 
5791 
class getItemAvailabilityAtLocation_args:
5792 
  """
5793 
  Attributes:
5794 
   - itemId
5978 rajveer 5795 
   - sourceId
23446 amit.gupta 5796 
   - stateId
5944 mandeep.dh 5797 
  """
5798 
 
5799 
  thrift_spec = (
5800 
    None, # 0
5801 
    (1, TType.I64, 'itemId', None, None, ), # 1
5978 rajveer 5802 
    (2, TType.I64, 'sourceId', None, None, ), # 2
23446 amit.gupta 5803 
    (3, TType.I64, 'stateId', None, None, ), # 3
5944 mandeep.dh 5804 
  )
5805 
 
23446 amit.gupta 5806 
  def __init__(self, itemId=None, sourceId=None, stateId=None,):
5944 mandeep.dh 5807 
    self.itemId = itemId
5978 rajveer 5808 
    self.sourceId = sourceId
23446 amit.gupta 5809 
    self.stateId = stateId
5944 mandeep.dh 5810 
 
5811 
  def read(self, iprot):
5812 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5813 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5814 
      return
5815 
    iprot.readStructBegin()
5816 
    while True:
5817 
      (fname, ftype, fid) = iprot.readFieldBegin()
5818 
      if ftype == TType.STOP:
5819 
        break
5820 
      if fid == 1:
5821 
        if ftype == TType.I64:
5822 
          self.itemId = iprot.readI64();
5823 
        else:
5824 
          iprot.skip(ftype)
5978 rajveer 5825 
      elif fid == 2:
5826 
        if ftype == TType.I64:
5827 
          self.sourceId = iprot.readI64();
5828 
        else:
5829 
          iprot.skip(ftype)
23446 amit.gupta 5830 
      elif fid == 3:
5831 
        if ftype == TType.I64:
5832 
          self.stateId = iprot.readI64();
5833 
        else:
5834 
          iprot.skip(ftype)
5944 mandeep.dh 5835 
      else:
5836 
        iprot.skip(ftype)
5837 
      iprot.readFieldEnd()
5838 
    iprot.readStructEnd()
5839 
 
5840 
  def write(self, oprot):
5841 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5842 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5843 
      return
5844 
    oprot.writeStructBegin('getItemAvailabilityAtLocation_args')
5845 
    if self.itemId is not None:
5846 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5847 
      oprot.writeI64(self.itemId)
5848 
      oprot.writeFieldEnd()
5978 rajveer 5849 
    if self.sourceId is not None:
5850 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
5851 
      oprot.writeI64(self.sourceId)
5852 
      oprot.writeFieldEnd()
23446 amit.gupta 5853 
    if self.stateId is not None:
5854 
      oprot.writeFieldBegin('stateId', TType.I64, 3)
5855 
      oprot.writeI64(self.stateId)
5856 
      oprot.writeFieldEnd()
5944 mandeep.dh 5857 
    oprot.writeFieldStop()
5858 
    oprot.writeStructEnd()
5859 
 
5860 
  def validate(self):
5861 
    return
5862 
 
5863 
 
5864 
  def __repr__(self):
5865 
    L = ['%s=%r' % (key, value)
5866 
      for key, value in self.__dict__.iteritems()]
5867 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5868 
 
5869 
  def __eq__(self, other):
5870 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5871 
 
5872 
  def __ne__(self, other):
5873 
    return not (self == other)
5874 
 
5875 
class getItemAvailabilityAtLocation_result:
5876 
  """
5877 
  Attributes:
5878 
   - success
5879 
   - isex
5880 
  """
5881 
 
5882 
  thrift_spec = (
5883 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
5884 
    (1, TType.STRUCT, 'isex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
5885 
  )
5886 
 
5887 
  def __init__(self, success=None, isex=None,):
5888 
    self.success = success
5889 
    self.isex = isex
5890 
 
5891 
  def read(self, iprot):
5892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5894 
      return
5895 
    iprot.readStructBegin()
5896 
    while True:
5897 
      (fname, ftype, fid) = iprot.readFieldBegin()
5898 
      if ftype == TType.STOP:
5899 
        break
5900 
      if fid == 0:
5901 
        if ftype == TType.LIST:
5902 
          self.success = []
8182 amar.kumar 5903 
          (_etype48, _size45) = iprot.readListBegin()
5904 
          for _i49 in xrange(_size45):
5905 
            _elem50 = iprot.readI64();
5906 
            self.success.append(_elem50)
5944 mandeep.dh 5907 
          iprot.readListEnd()
5908 
        else:
5909 
          iprot.skip(ftype)
5910 
      elif fid == 1:
5911 
        if ftype == TType.STRUCT:
5912 
          self.isex = InventoryServiceException()
5913 
          self.isex.read(iprot)
5914 
        else:
5915 
          iprot.skip(ftype)
5916 
      else:
5917 
        iprot.skip(ftype)
5918 
      iprot.readFieldEnd()
5919 
    iprot.readStructEnd()
5920 
 
5921 
  def write(self, oprot):
5922 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5923 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5924 
      return
5925 
    oprot.writeStructBegin('getItemAvailabilityAtLocation_result')
5926 
    if self.success is not None:
5927 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5928 
      oprot.writeListBegin(TType.I64, len(self.success))
8182 amar.kumar 5929 
      for iter51 in self.success:
5930 
        oprot.writeI64(iter51)
5944 mandeep.dh 5931 
      oprot.writeListEnd()
5932 
      oprot.writeFieldEnd()
5933 
    if self.isex is not None:
5934 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
5935 
      self.isex.write(oprot)
5936 
      oprot.writeFieldEnd()
5937 
    oprot.writeFieldStop()
5938 
    oprot.writeStructEnd()
5939 
 
5940 
  def validate(self):
5941 
    return
5942 
 
5943 
 
5944 
  def __repr__(self):
5945 
    L = ['%s=%r' % (key, value)
5946 
      for key, value in self.__dict__.iteritems()]
5947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5948 
 
5949 
  def __eq__(self, other):
5950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5951 
 
5952 
  def __ne__(self, other):
5953 
    return not (self == other)
5954 
 
5955 
class getAllWarehouses_args:
5956 
  """
5957 
  Attributes:
5958 
   - isActive
5959 
  """
5960 
 
5961 
  thrift_spec = (
5962 
    None, # 0
5963 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
5964 
  )
5965 
 
5966 
  def __init__(self, isActive=None,):
5967 
    self.isActive = isActive
5968 
 
5969 
  def read(self, iprot):
5970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5972 
      return
5973 
    iprot.readStructBegin()
5974 
    while True:
5975 
      (fname, ftype, fid) = iprot.readFieldBegin()
5976 
      if ftype == TType.STOP:
5977 
        break
5978 
      if fid == 1:
5979 
        if ftype == TType.BOOL:
5980 
          self.isActive = iprot.readBool();
5981 
        else:
5982 
          iprot.skip(ftype)
5983 
      else:
5984 
        iprot.skip(ftype)
5985 
      iprot.readFieldEnd()
5986 
    iprot.readStructEnd()
5987 
 
5988 
  def write(self, oprot):
5989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5991 
      return
5992 
    oprot.writeStructBegin('getAllWarehouses_args')
5993 
    if self.isActive is not None:
5994 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
5995 
      oprot.writeBool(self.isActive)
5996 
      oprot.writeFieldEnd()
5997 
    oprot.writeFieldStop()
5998 
    oprot.writeStructEnd()
5999 
 
6000 
  def validate(self):
6001 
    return
6002 
 
6003 
 
6004 
  def __repr__(self):
6005 
    L = ['%s=%r' % (key, value)
6006 
      for key, value in self.__dict__.iteritems()]
6007 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6008 
 
6009 
  def __eq__(self, other):
6010 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6011 
 
6012 
  def __ne__(self, other):
6013 
    return not (self == other)
6014 
 
6015 
class getAllWarehouses_result:
6016 
  """
6017 
  Attributes:
6018 
   - success
6019 
   - cex
6020 
  """
6021 
 
6022 
  thrift_spec = (
6023 
    (0, TType.LIST, 'success', (TType.STRUCT,(Warehouse, Warehouse.thrift_spec)), None, ), # 0
6024 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
6025 
  )
6026 
 
6027 
  def __init__(self, success=None, cex=None,):
6028 
    self.success = success
6029 
    self.cex = cex
6030 
 
6031 
  def read(self, iprot):
6032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6034 
      return
6035 
    iprot.readStructBegin()
6036 
    while True:
6037 
      (fname, ftype, fid) = iprot.readFieldBegin()
6038 
      if ftype == TType.STOP:
6039 
        break
6040 
      if fid == 0:
6041 
        if ftype == TType.LIST:
6042 
          self.success = []
8182 amar.kumar 6043 
          (_etype55, _size52) = iprot.readListBegin()
6044 
          for _i56 in xrange(_size52):
6045 
            _elem57 = Warehouse()
6046 
            _elem57.read(iprot)
6047 
            self.success.append(_elem57)
5944 mandeep.dh 6048 
          iprot.readListEnd()
6049 
        else:
6050 
          iprot.skip(ftype)
6051 
      elif fid == 1:
6052 
        if ftype == TType.STRUCT:
6053 
          self.cex = InventoryServiceException()
6054 
          self.cex.read(iprot)
6055 
        else:
6056 
          iprot.skip(ftype)
6057 
      else:
6058 
        iprot.skip(ftype)
6059 
      iprot.readFieldEnd()
6060 
    iprot.readStructEnd()
6061 
 
6062 
  def write(self, oprot):
6063 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6064 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6065 
      return
6066 
    oprot.writeStructBegin('getAllWarehouses_result')
6067 
    if self.success is not None:
6068 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6069 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 6070 
      for iter58 in self.success:
6071 
        iter58.write(oprot)
5944 mandeep.dh 6072 
      oprot.writeListEnd()
6073 
      oprot.writeFieldEnd()
6074 
    if self.cex is not None:
6075 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6076 
      self.cex.write(oprot)
6077 
      oprot.writeFieldEnd()
6078 
    oprot.writeFieldStop()
6079 
    oprot.writeStructEnd()
6080 
 
6081 
  def validate(self):
6082 
    return
6083 
 
6084 
 
6085 
  def __repr__(self):
6086 
    L = ['%s=%r' % (key, value)
6087 
      for key, value in self.__dict__.iteritems()]
6088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6089 
 
6090 
  def __eq__(self, other):
6091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6092 
 
6093 
  def __ne__(self, other):
6094 
    return not (self == other)
6095 
 
6096 
class getWarehouse_args:
6097 
  """
6098 
  Attributes:
6099 
   - warehouse_id
6100 
  """
6101 
 
6102 
  thrift_spec = (
6103 
    None, # 0
6104 
    (1, TType.I64, 'warehouse_id', None, None, ), # 1
6105 
  )
6106 
 
6107 
  def __init__(self, warehouse_id=None,):
6108 
    self.warehouse_id = warehouse_id
6109 
 
6110 
  def read(self, iprot):
6111 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6112 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6113 
      return
6114 
    iprot.readStructBegin()
6115 
    while True:
6116 
      (fname, ftype, fid) = iprot.readFieldBegin()
6117 
      if ftype == TType.STOP:
6118 
        break
6119 
      if fid == 1:
6120 
        if ftype == TType.I64:
6121 
          self.warehouse_id = iprot.readI64();
6122 
        else:
6123 
          iprot.skip(ftype)
6124 
      else:
6125 
        iprot.skip(ftype)
6126 
      iprot.readFieldEnd()
6127 
    iprot.readStructEnd()
6128 
 
6129 
  def write(self, oprot):
6130 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6131 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6132 
      return
6133 
    oprot.writeStructBegin('getWarehouse_args')
6134 
    if self.warehouse_id is not None:
6135 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 1)
6136 
      oprot.writeI64(self.warehouse_id)
6137 
      oprot.writeFieldEnd()
6138 
    oprot.writeFieldStop()
6139 
    oprot.writeStructEnd()
6140 
 
6141 
  def validate(self):
6142 
    return
6143 
 
6144 
 
6145 
  def __repr__(self):
6146 
    L = ['%s=%r' % (key, value)
6147 
      for key, value in self.__dict__.iteritems()]
6148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6149 
 
6150 
  def __eq__(self, other):
6151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6152 
 
6153 
  def __ne__(self, other):
6154 
    return not (self == other)
6155 
 
6156 
class getWarehouse_result:
6157 
  """
6158 
  Attributes:
6159 
   - success
6160 
   - cex
6161 
  """
6162 
 
6163 
  thrift_spec = (
6164 
    (0, TType.STRUCT, 'success', (Warehouse, Warehouse.thrift_spec), None, ), # 0
6165 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
6166 
  )
6167 
 
6168 
  def __init__(self, success=None, cex=None,):
6169 
    self.success = success
6170 
    self.cex = cex
6171 
 
6172 
  def read(self, iprot):
6173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6175 
      return
6176 
    iprot.readStructBegin()
6177 
    while True:
6178 
      (fname, ftype, fid) = iprot.readFieldBegin()
6179 
      if ftype == TType.STOP:
6180 
        break
6181 
      if fid == 0:
6182 
        if ftype == TType.STRUCT:
6183 
          self.success = Warehouse()
6184 
          self.success.read(iprot)
6185 
        else:
6186 
          iprot.skip(ftype)
6187 
      elif fid == 1:
6188 
        if ftype == TType.STRUCT:
6189 
          self.cex = InventoryServiceException()
6190 
          self.cex.read(iprot)
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('getWarehouse_result')
6203 
    if self.success is not None:
6204 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6205 
      self.success.write(oprot)
6206 
      oprot.writeFieldEnd()
6207 
    if self.cex is not None:
6208 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6209 
      self.cex.write(oprot)
6210 
      oprot.writeFieldEnd()
6211 
    oprot.writeFieldStop()
6212 
    oprot.writeStructEnd()
6213 
 
6214 
  def validate(self):
6215 
    return
6216 
 
6217 
 
6218 
  def __repr__(self):
6219 
    L = ['%s=%r' % (key, value)
6220 
      for key, value in self.__dict__.iteritems()]
6221 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6222 
 
6223 
  def __eq__(self, other):
6224 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6225 
 
6226 
  def __ne__(self, other):
6227 
    return not (self == other)
6228 
 
6229 
class getAllItemsForWarehouse_args:
6230 
  """
6231 
  Attributes:
6232 
   - warehouse_id
6233 
  """
6234 
 
6235 
  thrift_spec = (
6236 
    None, # 0
6237 
    (1, TType.I64, 'warehouse_id', None, None, ), # 1
6238 
  )
6239 
 
6240 
  def __init__(self, warehouse_id=None,):
6241 
    self.warehouse_id = warehouse_id
6242 
 
6243 
  def read(self, iprot):
6244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6246 
      return
6247 
    iprot.readStructBegin()
6248 
    while True:
6249 
      (fname, ftype, fid) = iprot.readFieldBegin()
6250 
      if ftype == TType.STOP:
6251 
        break
6252 
      if fid == 1:
6253 
        if ftype == TType.I64:
6254 
          self.warehouse_id = iprot.readI64();
6255 
        else:
6256 
          iprot.skip(ftype)
6257 
      else:
6258 
        iprot.skip(ftype)
6259 
      iprot.readFieldEnd()
6260 
    iprot.readStructEnd()
6261 
 
6262 
  def write(self, oprot):
6263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6265 
      return
6266 
    oprot.writeStructBegin('getAllItemsForWarehouse_args')
6267 
    if self.warehouse_id is not None:
6268 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 1)
6269 
      oprot.writeI64(self.warehouse_id)
6270 
      oprot.writeFieldEnd()
6271 
    oprot.writeFieldStop()
6272 
    oprot.writeStructEnd()
6273 
 
6274 
  def validate(self):
6275 
    return
6276 
 
6277 
 
6278 
  def __repr__(self):
6279 
    L = ['%s=%r' % (key, value)
6280 
      for key, value in self.__dict__.iteritems()]
6281 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6282 
 
6283 
  def __eq__(self, other):
6284 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6285 
 
6286 
  def __ne__(self, other):
6287 
    return not (self == other)
6288 
 
6289 
class getAllItemsForWarehouse_result:
6290 
  """
6291 
  Attributes:
6292 
   - success
6293 
   - cex
6294 
  """
6295 
 
6296 
  thrift_spec = (
6297 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6298 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
6299 
  )
6300 
 
6301 
  def __init__(self, success=None, cex=None,):
6302 
    self.success = success
6303 
    self.cex = cex
6304 
 
6305 
  def read(self, iprot):
6306 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6307 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6308 
      return
6309 
    iprot.readStructBegin()
6310 
    while True:
6311 
      (fname, ftype, fid) = iprot.readFieldBegin()
6312 
      if ftype == TType.STOP:
6313 
        break
6314 
      if fid == 0:
6315 
        if ftype == TType.LIST:
6316 
          self.success = []
8182 amar.kumar 6317 
          (_etype62, _size59) = iprot.readListBegin()
6318 
          for _i63 in xrange(_size59):
6319 
            _elem64 = iprot.readI64();
6320 
            self.success.append(_elem64)
5944 mandeep.dh 6321 
          iprot.readListEnd()
6322 
        else:
6323 
          iprot.skip(ftype)
6324 
      elif fid == 1:
6325 
        if ftype == TType.STRUCT:
6326 
          self.cex = InventoryServiceException()
6327 
          self.cex.read(iprot)
6328 
        else:
6329 
          iprot.skip(ftype)
6330 
      else:
6331 
        iprot.skip(ftype)
6332 
      iprot.readFieldEnd()
6333 
    iprot.readStructEnd()
6334 
 
6335 
  def write(self, oprot):
6336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6338 
      return
6339 
    oprot.writeStructBegin('getAllItemsForWarehouse_result')
6340 
    if self.success is not None:
6341 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6342 
      oprot.writeListBegin(TType.I64, len(self.success))
8182 amar.kumar 6343 
      for iter65 in self.success:
6344 
        oprot.writeI64(iter65)
5944 mandeep.dh 6345 
      oprot.writeListEnd()
6346 
      oprot.writeFieldEnd()
6347 
    if self.cex is not None:
6348 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6349 
      self.cex.write(oprot)
6350 
      oprot.writeFieldEnd()
6351 
    oprot.writeFieldStop()
6352 
    oprot.writeStructEnd()
6353 
 
6354 
  def validate(self):
6355 
    return
6356 
 
6357 
 
6358 
  def __repr__(self):
6359 
    L = ['%s=%r' % (key, value)
6360 
      for key, value in self.__dict__.iteritems()]
6361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6362 
 
6363 
  def __eq__(self, other):
6364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6365 
 
6366 
  def __ne__(self, other):
6367 
    return not (self == other)
6368 
 
5966 rajveer 6369 
class isOrderBillable_args:
6370 
  """
6371 
  Attributes:
6372 
   - itemId
6373 
   - warehouseId
6374 
   - sourceId
6375 
   - orderId
6376 
  """
6377 
 
6378 
  thrift_spec = (
6379 
    None, # 0
6380 
    (1, TType.I64, 'itemId', None, None, ), # 1
6381 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
6382 
    (3, TType.I64, 'sourceId', None, None, ), # 3
6383 
    (4, TType.I64, 'orderId', None, None, ), # 4
6384 
  )
6385 
 
6386 
  def __init__(self, itemId=None, warehouseId=None, sourceId=None, orderId=None,):
6387 
    self.itemId = itemId
6388 
    self.warehouseId = warehouseId
6389 
    self.sourceId = sourceId
6390 
    self.orderId = orderId
6391 
 
6392 
  def read(self, iprot):
6393 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6394 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6395 
      return
6396 
    iprot.readStructBegin()
6397 
    while True:
6398 
      (fname, ftype, fid) = iprot.readFieldBegin()
6399 
      if ftype == TType.STOP:
6400 
        break
6401 
      if fid == 1:
6402 
        if ftype == TType.I64:
6403 
          self.itemId = iprot.readI64();
6404 
        else:
6405 
          iprot.skip(ftype)
6406 
      elif fid == 2:
6407 
        if ftype == TType.I64:
6408 
          self.warehouseId = iprot.readI64();
6409 
        else:
6410 
          iprot.skip(ftype)
6411 
      elif fid == 3:
6412 
        if ftype == TType.I64:
6413 
          self.sourceId = iprot.readI64();
6414 
        else:
6415 
          iprot.skip(ftype)
6416 
      elif fid == 4:
6417 
        if ftype == TType.I64:
6418 
          self.orderId = iprot.readI64();
6419 
        else:
6420 
          iprot.skip(ftype)
6421 
      else:
6422 
        iprot.skip(ftype)
6423 
      iprot.readFieldEnd()
6424 
    iprot.readStructEnd()
6425 
 
6426 
  def write(self, oprot):
6427 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6428 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6429 
      return
6430 
    oprot.writeStructBegin('isOrderBillable_args')
6431 
    if self.itemId is not None:
6432 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
6433 
      oprot.writeI64(self.itemId)
6434 
      oprot.writeFieldEnd()
6435 
    if self.warehouseId is not None:
6436 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
6437 
      oprot.writeI64(self.warehouseId)
6438 
      oprot.writeFieldEnd()
6439 
    if self.sourceId is not None:
6440 
      oprot.writeFieldBegin('sourceId', TType.I64, 3)
6441 
      oprot.writeI64(self.sourceId)
6442 
      oprot.writeFieldEnd()
6443 
    if self.orderId is not None:
6444 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
6445 
      oprot.writeI64(self.orderId)
6446 
      oprot.writeFieldEnd()
6447 
    oprot.writeFieldStop()
6448 
    oprot.writeStructEnd()
6449 
 
6450 
  def validate(self):
6451 
    return
6452 
 
6453 
 
6454 
  def __repr__(self):
6455 
    L = ['%s=%r' % (key, value)
6456 
      for key, value in self.__dict__.iteritems()]
6457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6458 
 
6459 
  def __eq__(self, other):
6460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6461 
 
6462 
  def __ne__(self, other):
6463 
    return not (self == other)
6464 
 
6465 
class isOrderBillable_result:
6466 
  """
6467 
  Attributes:
6468 
   - success
6469 
  """
6470 
 
6471 
  thrift_spec = (
6472 
    (0, TType.BOOL, 'success', None, None, ), # 0
6473 
  )
6474 
 
6475 
  def __init__(self, success=None,):
6476 
    self.success = success
6477 
 
6478 
  def read(self, iprot):
6479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6481 
      return
6482 
    iprot.readStructBegin()
6483 
    while True:
6484 
      (fname, ftype, fid) = iprot.readFieldBegin()
6485 
      if ftype == TType.STOP:
6486 
        break
6487 
      if fid == 0:
6488 
        if ftype == TType.BOOL:
6489 
          self.success = iprot.readBool();
6490 
        else:
6491 
          iprot.skip(ftype)
6492 
      else:
6493 
        iprot.skip(ftype)
6494 
      iprot.readFieldEnd()
6495 
    iprot.readStructEnd()
6496 
 
6497 
  def write(self, oprot):
6498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6500 
      return
6501 
    oprot.writeStructBegin('isOrderBillable_result')
6502 
    if self.success is not None:
6503 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6504 
      oprot.writeBool(self.success)
6505 
      oprot.writeFieldEnd()
6506 
    oprot.writeFieldStop()
6507 
    oprot.writeStructEnd()
6508 
 
6509 
  def validate(self):
6510 
    return
6511 
 
6512 
 
6513 
  def __repr__(self):
6514 
    L = ['%s=%r' % (key, value)
6515 
      for key, value in self.__dict__.iteritems()]
6516 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6517 
 
6518 
  def __eq__(self, other):
6519 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6520 
 
6521 
  def __ne__(self, other):
6522 
    return not (self == other)
6523 
 
5944 mandeep.dh 6524 
class reserveItemInWarehouse_args:
6525 
  """
6526 
  Attributes:
6527 
   - itemId
6528 
   - warehouseId
5966 rajveer 6529 
   - sourceId
6530 
   - orderId
6531 
   - createdTimestamp
6532 
   - promisedShippingTimestamp
5944 mandeep.dh 6533 
   - quantity
6534 
  """
6535 
 
6536 
  thrift_spec = (
6537 
    None, # 0
6538 
    (1, TType.I64, 'itemId', None, None, ), # 1
6539 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
5966 rajveer 6540 
    (3, TType.I64, 'sourceId', None, None, ), # 3
6541 
    (4, TType.I64, 'orderId', None, None, ), # 4
6542 
    (5, TType.I64, 'createdTimestamp', None, None, ), # 5
6543 
    (6, TType.I64, 'promisedShippingTimestamp', None, None, ), # 6
6544 
    (7, TType.DOUBLE, 'quantity', None, None, ), # 7
5944 mandeep.dh 6545 
  )
6546 
 
5966 rajveer 6547 
  def __init__(self, itemId=None, warehouseId=None, sourceId=None, orderId=None, createdTimestamp=None, promisedShippingTimestamp=None, quantity=None,):
5944 mandeep.dh 6548 
    self.itemId = itemId
6549 
    self.warehouseId = warehouseId
5966 rajveer 6550 
    self.sourceId = sourceId
6551 
    self.orderId = orderId
6552 
    self.createdTimestamp = createdTimestamp
6553 
    self.promisedShippingTimestamp = promisedShippingTimestamp
5944 mandeep.dh 6554 
    self.quantity = quantity
6555 
 
6556 
  def read(self, iprot):
6557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6559 
      return
6560 
    iprot.readStructBegin()
6561 
    while True:
6562 
      (fname, ftype, fid) = iprot.readFieldBegin()
6563 
      if ftype == TType.STOP:
6564 
        break
6565 
      if fid == 1:
6566 
        if ftype == TType.I64:
6567 
          self.itemId = iprot.readI64();
6568 
        else:
6569 
          iprot.skip(ftype)
6570 
      elif fid == 2:
6571 
        if ftype == TType.I64:
6572 
          self.warehouseId = iprot.readI64();
6573 
        else:
6574 
          iprot.skip(ftype)
6575 
      elif fid == 3:
5966 rajveer 6576 
        if ftype == TType.I64:
6577 
          self.sourceId = iprot.readI64();
6578 
        else:
6579 
          iprot.skip(ftype)
6580 
      elif fid == 4:
6581 
        if ftype == TType.I64:
6582 
          self.orderId = iprot.readI64();
6583 
        else:
6584 
          iprot.skip(ftype)
6585 
      elif fid == 5:
6586 
        if ftype == TType.I64:
6587 
          self.createdTimestamp = iprot.readI64();
6588 
        else:
6589 
          iprot.skip(ftype)
6590 
      elif fid == 6:
6591 
        if ftype == TType.I64:
6592 
          self.promisedShippingTimestamp = iprot.readI64();
6593 
        else:
6594 
          iprot.skip(ftype)
6595 
      elif fid == 7:
5944 mandeep.dh 6596 
        if ftype == TType.DOUBLE:
6597 
          self.quantity = iprot.readDouble();
6598 
        else:
6599 
          iprot.skip(ftype)
6600 
      else:
6601 
        iprot.skip(ftype)
6602 
      iprot.readFieldEnd()
6603 
    iprot.readStructEnd()
6604 
 
6605 
  def write(self, oprot):
6606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6608 
      return
6609 
    oprot.writeStructBegin('reserveItemInWarehouse_args')
6610 
    if self.itemId is not None:
6611 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
6612 
      oprot.writeI64(self.itemId)
6613 
      oprot.writeFieldEnd()
6614 
    if self.warehouseId is not None:
6615 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
6616 
      oprot.writeI64(self.warehouseId)
6617 
      oprot.writeFieldEnd()
5966 rajveer 6618 
    if self.sourceId is not None:
6619 
      oprot.writeFieldBegin('sourceId', TType.I64, 3)
6620 
      oprot.writeI64(self.sourceId)
6621 
      oprot.writeFieldEnd()
6622 
    if self.orderId is not None:
6623 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
6624 
      oprot.writeI64(self.orderId)
6625 
      oprot.writeFieldEnd()
6626 
    if self.createdTimestamp is not None:
6627 
      oprot.writeFieldBegin('createdTimestamp', TType.I64, 5)
6628 
      oprot.writeI64(self.createdTimestamp)
6629 
      oprot.writeFieldEnd()
6630 
    if self.promisedShippingTimestamp is not None:
6631 
      oprot.writeFieldBegin('promisedShippingTimestamp', TType.I64, 6)
6632 
      oprot.writeI64(self.promisedShippingTimestamp)
6633 
      oprot.writeFieldEnd()
5944 mandeep.dh 6634 
    if self.quantity is not None:
5966 rajveer 6635 
      oprot.writeFieldBegin('quantity', TType.DOUBLE, 7)
5944 mandeep.dh 6636 
      oprot.writeDouble(self.quantity)
6637 
      oprot.writeFieldEnd()
6638 
    oprot.writeFieldStop()
6639 
    oprot.writeStructEnd()
6640 
 
6641 
  def validate(self):
6642 
    return
6643 
 
6644 
 
6645 
  def __repr__(self):
6646 
    L = ['%s=%r' % (key, value)
6647 
      for key, value in self.__dict__.iteritems()]
6648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6649 
 
6650 
  def __eq__(self, other):
6651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6652 
 
6653 
  def __ne__(self, other):
6654 
    return not (self == other)
6655 
 
6656 
class reserveItemInWarehouse_result:
6657 
  """
6658 
  Attributes:
6659 
   - success
6660 
   - cex
6661 
  """
6662 
 
6663 
  thrift_spec = (
6664 
    (0, TType.BOOL, 'success', None, None, ), # 0
6665 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
6666 
  )
6667 
 
6668 
  def __init__(self, success=None, cex=None,):
6669 
    self.success = success
6670 
    self.cex = cex
6671 
 
6672 
  def read(self, iprot):
6673 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6674 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6675 
      return
6676 
    iprot.readStructBegin()
6677 
    while True:
6678 
      (fname, ftype, fid) = iprot.readFieldBegin()
6679 
      if ftype == TType.STOP:
6680 
        break
6681 
      if fid == 0:
6682 
        if ftype == TType.BOOL:
6683 
          self.success = iprot.readBool();
6684 
        else:
6685 
          iprot.skip(ftype)
6686 
      elif fid == 1:
6687 
        if ftype == TType.STRUCT:
6688 
          self.cex = InventoryServiceException()
6689 
          self.cex.read(iprot)
6690 
        else:
6691 
          iprot.skip(ftype)
6692 
      else:
6693 
        iprot.skip(ftype)
6694 
      iprot.readFieldEnd()
6695 
    iprot.readStructEnd()
6696 
 
6697 
  def write(self, oprot):
6698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6700 
      return
6701 
    oprot.writeStructBegin('reserveItemInWarehouse_result')
6702 
    if self.success is not None:
6703 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6704 
      oprot.writeBool(self.success)
6705 
      oprot.writeFieldEnd()
6706 
    if self.cex is not None:
6707 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6708 
      self.cex.write(oprot)
6709 
      oprot.writeFieldEnd()
6710 
    oprot.writeFieldStop()
6711 
    oprot.writeStructEnd()
6712 
 
6713 
  def validate(self):
6714 
    return
6715 
 
6716 
 
6717 
  def __repr__(self):
6718 
    L = ['%s=%r' % (key, value)
6719 
      for key, value in self.__dict__.iteritems()]
6720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6721 
 
6722 
  def __eq__(self, other):
6723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6724 
 
6725 
  def __ne__(self, other):
6726 
    return not (self == other)
6727 
 
7968 amar.kumar 6728 
class updateReservationForOrder_args:
6729 
  """
6730 
  Attributes:
6731 
   - itemId
6732 
   - warehouseId
6733 
   - sourceId
6734 
   - orderId
6735 
   - createdTimestamp
6736 
   - promisedShippingTimestamp
6737 
   - quantity
6738 
  """
6739 
 
6740 
  thrift_spec = (
6741 
    None, # 0
6742 
    (1, TType.I64, 'itemId', None, None, ), # 1
6743 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
6744 
    (3, TType.I64, 'sourceId', None, None, ), # 3
6745 
    (4, TType.I64, 'orderId', None, None, ), # 4
6746 
    (5, TType.I64, 'createdTimestamp', None, None, ), # 5
6747 
    (6, TType.I64, 'promisedShippingTimestamp', None, None, ), # 6
6748 
    (7, TType.DOUBLE, 'quantity', None, None, ), # 7
6749 
  )
6750 
 
6751 
  def __init__(self, itemId=None, warehouseId=None, sourceId=None, orderId=None, createdTimestamp=None, promisedShippingTimestamp=None, quantity=None,):
6752 
    self.itemId = itemId
6753 
    self.warehouseId = warehouseId
6754 
    self.sourceId = sourceId
6755 
    self.orderId = orderId
6756 
    self.createdTimestamp = createdTimestamp
6757 
    self.promisedShippingTimestamp = promisedShippingTimestamp
6758 
    self.quantity = quantity
6759 
 
6760 
  def read(self, iprot):
6761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6763 
      return
6764 
    iprot.readStructBegin()
6765 
    while True:
6766 
      (fname, ftype, fid) = iprot.readFieldBegin()
6767 
      if ftype == TType.STOP:
6768 
        break
6769 
      if fid == 1:
6770 
        if ftype == TType.I64:
6771 
          self.itemId = iprot.readI64();
6772 
        else:
6773 
          iprot.skip(ftype)
6774 
      elif fid == 2:
6775 
        if ftype == TType.I64:
6776 
          self.warehouseId = iprot.readI64();
6777 
        else:
6778 
          iprot.skip(ftype)
6779 
      elif fid == 3:
6780 
        if ftype == TType.I64:
6781 
          self.sourceId = iprot.readI64();
6782 
        else:
6783 
          iprot.skip(ftype)
6784 
      elif fid == 4:
6785 
        if ftype == TType.I64:
6786 
          self.orderId = iprot.readI64();
6787 
        else:
6788 
          iprot.skip(ftype)
6789 
      elif fid == 5:
6790 
        if ftype == TType.I64:
6791 
          self.createdTimestamp = iprot.readI64();
6792 
        else:
6793 
          iprot.skip(ftype)
6794 
      elif fid == 6:
6795 
        if ftype == TType.I64:
6796 
          self.promisedShippingTimestamp = iprot.readI64();
6797 
        else:
6798 
          iprot.skip(ftype)
6799 
      elif fid == 7:
6800 
        if ftype == TType.DOUBLE:
6801 
          self.quantity = iprot.readDouble();
6802 
        else:
6803 
          iprot.skip(ftype)
6804 
      else:
6805 
        iprot.skip(ftype)
6806 
      iprot.readFieldEnd()
6807 
    iprot.readStructEnd()
6808 
 
6809 
  def write(self, oprot):
6810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6812 
      return
6813 
    oprot.writeStructBegin('updateReservationForOrder_args')
6814 
    if self.itemId is not None:
6815 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
6816 
      oprot.writeI64(self.itemId)
6817 
      oprot.writeFieldEnd()
6818 
    if self.warehouseId is not None:
6819 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
6820 
      oprot.writeI64(self.warehouseId)
6821 
      oprot.writeFieldEnd()
6822 
    if self.sourceId is not None:
6823 
      oprot.writeFieldBegin('sourceId', TType.I64, 3)
6824 
      oprot.writeI64(self.sourceId)
6825 
      oprot.writeFieldEnd()
6826 
    if self.orderId is not None:
6827 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
6828 
      oprot.writeI64(self.orderId)
6829 
      oprot.writeFieldEnd()
6830 
    if self.createdTimestamp is not None:
6831 
      oprot.writeFieldBegin('createdTimestamp', TType.I64, 5)
6832 
      oprot.writeI64(self.createdTimestamp)
6833 
      oprot.writeFieldEnd()
6834 
    if self.promisedShippingTimestamp is not None:
6835 
      oprot.writeFieldBegin('promisedShippingTimestamp', TType.I64, 6)
6836 
      oprot.writeI64(self.promisedShippingTimestamp)
6837 
      oprot.writeFieldEnd()
6838 
    if self.quantity is not None:
6839 
      oprot.writeFieldBegin('quantity', TType.DOUBLE, 7)
6840 
      oprot.writeDouble(self.quantity)
6841 
      oprot.writeFieldEnd()
6842 
    oprot.writeFieldStop()
6843 
    oprot.writeStructEnd()
6844 
 
6845 
  def validate(self):
6846 
    return
6847 
 
6848 
 
6849 
  def __repr__(self):
6850 
    L = ['%s=%r' % (key, value)
6851 
      for key, value in self.__dict__.iteritems()]
6852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6853 
 
6854 
  def __eq__(self, other):
6855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6856 
 
6857 
  def __ne__(self, other):
6858 
    return not (self == other)
6859 
 
6860 
class updateReservationForOrder_result:
6861 
  """
6862 
  Attributes:
6863 
   - success
6864 
   - cex
6865 
  """
6866 
 
6867 
  thrift_spec = (
6868 
    (0, TType.BOOL, 'success', None, None, ), # 0
6869 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
6870 
  )
6871 
 
6872 
  def __init__(self, success=None, cex=None,):
6873 
    self.success = success
6874 
    self.cex = cex
6875 
 
6876 
  def read(self, iprot):
6877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6879 
      return
6880 
    iprot.readStructBegin()
6881 
    while True:
6882 
      (fname, ftype, fid) = iprot.readFieldBegin()
6883 
      if ftype == TType.STOP:
6884 
        break
6885 
      if fid == 0:
6886 
        if ftype == TType.BOOL:
6887 
          self.success = iprot.readBool();
6888 
        else:
6889 
          iprot.skip(ftype)
6890 
      elif fid == 1:
6891 
        if ftype == TType.STRUCT:
6892 
          self.cex = InventoryServiceException()
6893 
          self.cex.read(iprot)
6894 
        else:
6895 
          iprot.skip(ftype)
6896 
      else:
6897 
        iprot.skip(ftype)
6898 
      iprot.readFieldEnd()
6899 
    iprot.readStructEnd()
6900 
 
6901 
  def write(self, oprot):
6902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6904 
      return
6905 
    oprot.writeStructBegin('updateReservationForOrder_result')
6906 
    if self.success is not None:
6907 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6908 
      oprot.writeBool(self.success)
6909 
      oprot.writeFieldEnd()
6910 
    if self.cex is not None:
6911 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6912 
      self.cex.write(oprot)
6913 
      oprot.writeFieldEnd()
6914 
    oprot.writeFieldStop()
6915 
    oprot.writeStructEnd()
6916 
 
6917 
  def validate(self):
6918 
    return
6919 
 
6920 
 
6921 
  def __repr__(self):
6922 
    L = ['%s=%r' % (key, value)
6923 
      for key, value in self.__dict__.iteritems()]
6924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6925 
 
6926 
  def __eq__(self, other):
6927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6928 
 
6929 
  def __ne__(self, other):
6930 
    return not (self == other)
6931 
 
5944 mandeep.dh 6932 
class reduceReservationCount_args:
6933 
  """
6934 
  Attributes:
6935 
   - itemId
6936 
   - warehouseId
5966 rajveer 6937 
   - sourceId
6938 
   - orderId
5944 mandeep.dh 6939 
   - quantity
6940 
  """
6941 
 
6942 
  thrift_spec = (
6943 
    None, # 0
6944 
    (1, TType.I64, 'itemId', None, None, ), # 1
6945 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
5966 rajveer 6946 
    (3, TType.I64, 'sourceId', None, None, ), # 3
6947 
    (4, TType.I64, 'orderId', None, None, ), # 4
6948 
    (5, TType.DOUBLE, 'quantity', None, None, ), # 5
5944 mandeep.dh 6949 
  )
6950 
 
5966 rajveer 6951 
  def __init__(self, itemId=None, warehouseId=None, sourceId=None, orderId=None, quantity=None,):
5944 mandeep.dh 6952 
    self.itemId = itemId
6953 
    self.warehouseId = warehouseId
5966 rajveer 6954 
    self.sourceId = sourceId
6955 
    self.orderId = orderId
5944 mandeep.dh 6956 
    self.quantity = quantity
6957 
 
6958 
  def read(self, iprot):
6959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6961 
      return
6962 
    iprot.readStructBegin()
6963 
    while True:
6964 
      (fname, ftype, fid) = iprot.readFieldBegin()
6965 
      if ftype == TType.STOP:
6966 
        break
6967 
      if fid == 1:
6968 
        if ftype == TType.I64:
6969 
          self.itemId = iprot.readI64();
6970 
        else:
6971 
          iprot.skip(ftype)
6972 
      elif fid == 2:
6973 
        if ftype == TType.I64:
6974 
          self.warehouseId = iprot.readI64();
6975 
        else:
6976 
          iprot.skip(ftype)
6977 
      elif fid == 3:
5966 rajveer 6978 
        if ftype == TType.I64:
6979 
          self.sourceId = iprot.readI64();
6980 
        else:
6981 
          iprot.skip(ftype)
6982 
      elif fid == 4:
6983 
        if ftype == TType.I64:
6984 
          self.orderId = iprot.readI64();
6985 
        else:
6986 
          iprot.skip(ftype)
6987 
      elif fid == 5:
5944 mandeep.dh 6988 
        if ftype == TType.DOUBLE:
6989 
          self.quantity = iprot.readDouble();
6990 
        else:
6991 
          iprot.skip(ftype)
6992 
      else:
6993 
        iprot.skip(ftype)
6994 
      iprot.readFieldEnd()
6995 
    iprot.readStructEnd()
6996 
 
6997 
  def write(self, oprot):
6998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7000 
      return
7001 
    oprot.writeStructBegin('reduceReservationCount_args')
7002 
    if self.itemId is not None:
7003 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
7004 
      oprot.writeI64(self.itemId)
7005 
      oprot.writeFieldEnd()
7006 
    if self.warehouseId is not None:
7007 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
7008 
      oprot.writeI64(self.warehouseId)
7009 
      oprot.writeFieldEnd()
5966 rajveer 7010 
    if self.sourceId is not None:
7011 
      oprot.writeFieldBegin('sourceId', TType.I64, 3)
7012 
      oprot.writeI64(self.sourceId)
7013 
      oprot.writeFieldEnd()
7014 
    if self.orderId is not None:
7015 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
7016 
      oprot.writeI64(self.orderId)
7017 
      oprot.writeFieldEnd()
5944 mandeep.dh 7018 
    if self.quantity is not None:
5966 rajveer 7019 
      oprot.writeFieldBegin('quantity', TType.DOUBLE, 5)
5944 mandeep.dh 7020 
      oprot.writeDouble(self.quantity)
7021 
      oprot.writeFieldEnd()
7022 
    oprot.writeFieldStop()
7023 
    oprot.writeStructEnd()
7024 
 
7025 
  def validate(self):
7026 
    return
7027 
 
7028 
 
7029 
  def __repr__(self):
7030 
    L = ['%s=%r' % (key, value)
7031 
      for key, value in self.__dict__.iteritems()]
7032 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7033 
 
7034 
  def __eq__(self, other):
7035 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7036 
 
7037 
  def __ne__(self, other):
7038 
    return not (self == other)
7039 
 
7040 
class reduceReservationCount_result:
7041 
  """
7042 
  Attributes:
7043 
   - success
7044 
   - cex
7045 
  """
7046 
 
7047 
  thrift_spec = (
7048 
    (0, TType.BOOL, 'success', None, None, ), # 0
7049 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
7050 
  )
7051 
 
7052 
  def __init__(self, success=None, cex=None,):
7053 
    self.success = success
7054 
    self.cex = cex
7055 
 
7056 
  def read(self, iprot):
7057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7059 
      return
7060 
    iprot.readStructBegin()
7061 
    while True:
7062 
      (fname, ftype, fid) = iprot.readFieldBegin()
7063 
      if ftype == TType.STOP:
7064 
        break
7065 
      if fid == 0:
7066 
        if ftype == TType.BOOL:
7067 
          self.success = iprot.readBool();
7068 
        else:
7069 
          iprot.skip(ftype)
7070 
      elif fid == 1:
7071 
        if ftype == TType.STRUCT:
7072 
          self.cex = InventoryServiceException()
7073 
          self.cex.read(iprot)
7074 
        else:
7075 
          iprot.skip(ftype)
7076 
      else:
7077 
        iprot.skip(ftype)
7078 
      iprot.readFieldEnd()
7079 
    iprot.readStructEnd()
7080 
 
7081 
  def write(self, oprot):
7082 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7083 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7084 
      return
7085 
    oprot.writeStructBegin('reduceReservationCount_result')
7086 
    if self.success is not None:
7087 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7088 
      oprot.writeBool(self.success)
7089 
      oprot.writeFieldEnd()
7090 
    if self.cex is not None:
7091 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7092 
      self.cex.write(oprot)
7093 
      oprot.writeFieldEnd()
7094 
    oprot.writeFieldStop()
7095 
    oprot.writeStructEnd()
7096 
 
7097 
  def validate(self):
7098 
    return
7099 
 
7100 
 
7101 
  def __repr__(self):
7102 
    L = ['%s=%r' % (key, value)
7103 
      for key, value in self.__dict__.iteritems()]
7104 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7105 
 
7106 
  def __eq__(self, other):
7107 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7108 
 
7109 
  def __ne__(self, other):
7110 
    return not (self == other)
7111 
 
7112 
class getItemPricing_args:
7113 
  """
7114 
  Attributes:
7115 
   - itemId
7116 
   - vendorId
7117 
  """
7118 
 
7119 
  thrift_spec = (
7120 
    None, # 0
7121 
    (1, TType.I64, 'itemId', None, None, ), # 1
7122 
    (2, TType.I64, 'vendorId', None, None, ), # 2
7123 
  )
7124 
 
7125 
  def __init__(self, itemId=None, vendorId=None,):
7126 
    self.itemId = itemId
7127 
    self.vendorId = vendorId
7128 
 
7129 
  def read(self, iprot):
7130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7132 
      return
7133 
    iprot.readStructBegin()
7134 
    while True:
7135 
      (fname, ftype, fid) = iprot.readFieldBegin()
7136 
      if ftype == TType.STOP:
7137 
        break
7138 
      if fid == 1:
7139 
        if ftype == TType.I64:
7140 
          self.itemId = iprot.readI64();
7141 
        else:
7142 
          iprot.skip(ftype)
7143 
      elif fid == 2:
7144 
        if ftype == TType.I64:
7145 
          self.vendorId = iprot.readI64();
7146 
        else:
7147 
          iprot.skip(ftype)
7148 
      else:
7149 
        iprot.skip(ftype)
7150 
      iprot.readFieldEnd()
7151 
    iprot.readStructEnd()
7152 
 
7153 
  def write(self, oprot):
7154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7156 
      return
7157 
    oprot.writeStructBegin('getItemPricing_args')
7158 
    if self.itemId is not None:
7159 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
7160 
      oprot.writeI64(self.itemId)
7161 
      oprot.writeFieldEnd()
7162 
    if self.vendorId is not None:
7163 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
7164 
      oprot.writeI64(self.vendorId)
7165 
      oprot.writeFieldEnd()
7166 
    oprot.writeFieldStop()
7167 
    oprot.writeStructEnd()
7168 
 
7169 
  def validate(self):
7170 
    return
7171 
 
7172 
 
7173 
  def __repr__(self):
7174 
    L = ['%s=%r' % (key, value)
7175 
      for key, value in self.__dict__.iteritems()]
7176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7177 
 
7178 
  def __eq__(self, other):
7179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7180 
 
7181 
  def __ne__(self, other):
7182 
    return not (self == other)
7183 
 
7184 
class getItemPricing_result:
7185 
  """
7186 
  Attributes:
7187 
   - success
7188 
   - cex
7189 
  """
7190 
 
7191 
  thrift_spec = (
7192 
    (0, TType.STRUCT, 'success', (VendorItemPricing, VendorItemPricing.thrift_spec), None, ), # 0
7193 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
7194 
  )
7195 
 
7196 
  def __init__(self, success=None, cex=None,):
7197 
    self.success = success
7198 
    self.cex = cex
7199 
 
7200 
  def read(self, iprot):
7201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7203 
      return
7204 
    iprot.readStructBegin()
7205 
    while True:
7206 
      (fname, ftype, fid) = iprot.readFieldBegin()
7207 
      if ftype == TType.STOP:
7208 
        break
7209 
      if fid == 0:
7210 
        if ftype == TType.STRUCT:
7211 
          self.success = VendorItemPricing()
7212 
          self.success.read(iprot)
7213 
        else:
7214 
          iprot.skip(ftype)
7215 
      elif fid == 1:
7216 
        if ftype == TType.STRUCT:
7217 
          self.cex = InventoryServiceException()
7218 
          self.cex.read(iprot)
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('getItemPricing_result')
7231 
    if self.success is not None:
7232 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7233 
      self.success.write(oprot)
7234 
      oprot.writeFieldEnd()
7235 
    if self.cex is not None:
7236 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7237 
      self.cex.write(oprot)
7238 
      oprot.writeFieldEnd()
7239 
    oprot.writeFieldStop()
7240 
    oprot.writeStructEnd()
7241 
 
7242 
  def validate(self):
7243 
    return
7244 
 
7245 
 
7246 
  def __repr__(self):
7247 
    L = ['%s=%r' % (key, value)
7248 
      for key, value in self.__dict__.iteritems()]
7249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7250 
 
7251 
  def __eq__(self, other):
7252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7253 
 
7254 
  def __ne__(self, other):
7255 
    return not (self == other)
7256 
 
7257 
class getAllItemPricing_args:
7258 
  """
7259 
  Attributes:
7260 
   - itemId
7261 
  """
7262 
 
7263 
  thrift_spec = (
7264 
    None, # 0
7265 
    (1, TType.I64, 'itemId', None, None, ), # 1
7266 
  )
7267 
 
7268 
  def __init__(self, itemId=None,):
7269 
    self.itemId = itemId
7270 
 
7271 
  def read(self, iprot):
7272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7274 
      return
7275 
    iprot.readStructBegin()
7276 
    while True:
7277 
      (fname, ftype, fid) = iprot.readFieldBegin()
7278 
      if ftype == TType.STOP:
7279 
        break
7280 
      if fid == 1:
7281 
        if ftype == TType.I64:
7282 
          self.itemId = iprot.readI64();
7283 
        else:
7284 
          iprot.skip(ftype)
7285 
      else:
7286 
        iprot.skip(ftype)
7287 
      iprot.readFieldEnd()
7288 
    iprot.readStructEnd()
7289 
 
7290 
  def write(self, oprot):
7291 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7292 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7293 
      return
7294 
    oprot.writeStructBegin('getAllItemPricing_args')
7295 
    if self.itemId is not None:
7296 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
7297 
      oprot.writeI64(self.itemId)
7298 
      oprot.writeFieldEnd()
7299 
    oprot.writeFieldStop()
7300 
    oprot.writeStructEnd()
7301 
 
7302 
  def validate(self):
7303 
    return
7304 
 
7305 
 
7306 
  def __repr__(self):
7307 
    L = ['%s=%r' % (key, value)
7308 
      for key, value in self.__dict__.iteritems()]
7309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7310 
 
7311 
  def __eq__(self, other):
7312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7313 
 
7314 
  def __ne__(self, other):
7315 
    return not (self == other)
7316 
 
7317 
class getAllItemPricing_result:
7318 
  """
7319 
  Attributes:
7320 
   - success
7321 
   - cex
7322 
  """
7323 
 
7324 
  thrift_spec = (
7325 
    (0, TType.LIST, 'success', (TType.STRUCT,(VendorItemPricing, VendorItemPricing.thrift_spec)), None, ), # 0
7326 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
7327 
  )
7328 
 
7329 
  def __init__(self, success=None, cex=None,):
7330 
    self.success = success
7331 
    self.cex = cex
7332 
 
7333 
  def read(self, iprot):
7334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7336 
      return
7337 
    iprot.readStructBegin()
7338 
    while True:
7339 
      (fname, ftype, fid) = iprot.readFieldBegin()
7340 
      if ftype == TType.STOP:
7341 
        break
7342 
      if fid == 0:
7343 
        if ftype == TType.LIST:
7344 
          self.success = []
8182 amar.kumar 7345 
          (_etype69, _size66) = iprot.readListBegin()
7346 
          for _i70 in xrange(_size66):
7347 
            _elem71 = VendorItemPricing()
7348 
            _elem71.read(iprot)
7349 
            self.success.append(_elem71)
5944 mandeep.dh 7350 
          iprot.readListEnd()
7351 
        else:
7352 
          iprot.skip(ftype)
7353 
      elif fid == 1:
7354 
        if ftype == TType.STRUCT:
7355 
          self.cex = InventoryServiceException()
7356 
          self.cex.read(iprot)
7357 
        else:
7358 
          iprot.skip(ftype)
7359 
      else:
7360 
        iprot.skip(ftype)
7361 
      iprot.readFieldEnd()
7362 
    iprot.readStructEnd()
7363 
 
7364 
  def write(self, oprot):
7365 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7366 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7367 
      return
7368 
    oprot.writeStructBegin('getAllItemPricing_result')
7369 
    if self.success is not None:
7370 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7371 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 7372 
      for iter72 in self.success:
7373 
        iter72.write(oprot)
5944 mandeep.dh 7374 
      oprot.writeListEnd()
7375 
      oprot.writeFieldEnd()
7376 
    if self.cex is not None:
7377 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7378 
      self.cex.write(oprot)
7379 
      oprot.writeFieldEnd()
7380 
    oprot.writeFieldStop()
7381 
    oprot.writeStructEnd()
7382 
 
7383 
  def validate(self):
7384 
    return
7385 
 
7386 
 
7387 
  def __repr__(self):
7388 
    L = ['%s=%r' % (key, value)
7389 
      for key, value in self.__dict__.iteritems()]
7390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7391 
 
7392 
  def __eq__(self, other):
7393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7394 
 
7395 
  def __ne__(self, other):
7396 
    return not (self == other)
7397 
 
7398 
class addVendorItemPricing_args:
7399 
  """
7400 
  Attributes:
7401 
   - vendorItemPricing
7402 
  """
7403 
 
7404 
  thrift_spec = (
7405 
    None, # 0
7406 
    (1, TType.STRUCT, 'vendorItemPricing', (VendorItemPricing, VendorItemPricing.thrift_spec), None, ), # 1
7407 
  )
7408 
 
7409 
  def __init__(self, vendorItemPricing=None,):
7410 
    self.vendorItemPricing = vendorItemPricing
7411 
 
7412 
  def read(self, iprot):
7413 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7414 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7415 
      return
7416 
    iprot.readStructBegin()
7417 
    while True:
7418 
      (fname, ftype, fid) = iprot.readFieldBegin()
7419 
      if ftype == TType.STOP:
7420 
        break
7421 
      if fid == 1:
7422 
        if ftype == TType.STRUCT:
7423 
          self.vendorItemPricing = VendorItemPricing()
7424 
          self.vendorItemPricing.read(iprot)
7425 
        else:
7426 
          iprot.skip(ftype)
7427 
      else:
7428 
        iprot.skip(ftype)
7429 
      iprot.readFieldEnd()
7430 
    iprot.readStructEnd()
7431 
 
7432 
  def write(self, oprot):
7433 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7434 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7435 
      return
7436 
    oprot.writeStructBegin('addVendorItemPricing_args')
7437 
    if self.vendorItemPricing is not None:
7438 
      oprot.writeFieldBegin('vendorItemPricing', TType.STRUCT, 1)
7439 
      self.vendorItemPricing.write(oprot)
7440 
      oprot.writeFieldEnd()
7441 
    oprot.writeFieldStop()
7442 
    oprot.writeStructEnd()
7443 
 
7444 
  def validate(self):
7445 
    return
7446 
 
7447 
 
7448 
  def __repr__(self):
7449 
    L = ['%s=%r' % (key, value)
7450 
      for key, value in self.__dict__.iteritems()]
7451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7452 
 
7453 
  def __eq__(self, other):
7454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7455 
 
7456 
  def __ne__(self, other):
7457 
    return not (self == other)
7458 
 
7459 
class addVendorItemPricing_result:
7460 
  """
7461 
  Attributes:
7462 
   - cex
7463 
  """
7464 
 
7465 
  thrift_spec = (
7466 
    None, # 0
7467 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
7468 
  )
7469 
 
7470 
  def __init__(self, cex=None,):
7471 
    self.cex = cex
7472 
 
7473 
  def read(self, iprot):
7474 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7475 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7476 
      return
7477 
    iprot.readStructBegin()
7478 
    while True:
7479 
      (fname, ftype, fid) = iprot.readFieldBegin()
7480 
      if ftype == TType.STOP:
7481 
        break
7482 
      if fid == 1:
7483 
        if ftype == TType.STRUCT:
7484 
          self.cex = InventoryServiceException()
7485 
          self.cex.read(iprot)
7486 
        else:
7487 
          iprot.skip(ftype)
7488 
      else:
7489 
        iprot.skip(ftype)
7490 
      iprot.readFieldEnd()
7491 
    iprot.readStructEnd()
7492 
 
7493 
  def write(self, oprot):
7494 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7495 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7496 
      return
7497 
    oprot.writeStructBegin('addVendorItemPricing_result')
7498 
    if self.cex is not None:
7499 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7500 
      self.cex.write(oprot)
7501 
      oprot.writeFieldEnd()
7502 
    oprot.writeFieldStop()
7503 
    oprot.writeStructEnd()
7504 
 
7505 
  def validate(self):
7506 
    return
7507 
 
7508 
 
7509 
  def __repr__(self):
7510 
    L = ['%s=%r' % (key, value)
7511 
      for key, value in self.__dict__.iteritems()]
7512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7513 
 
7514 
  def __eq__(self, other):
7515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7516 
 
7517 
  def __ne__(self, other):
7518 
    return not (self == other)
7519 
 
7520 
class getVendor_args:
7521 
  """
7522 
  Attributes:
7523 
   - vendorId
7524 
  """
7525 
 
7526 
  thrift_spec = (
7527 
    None, # 0
7528 
    (1, TType.I64, 'vendorId', None, None, ), # 1
7529 
  )
7530 
 
7531 
  def __init__(self, vendorId=None,):
7532 
    self.vendorId = vendorId
7533 
 
7534 
  def read(self, iprot):
7535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7537 
      return
7538 
    iprot.readStructBegin()
7539 
    while True:
7540 
      (fname, ftype, fid) = iprot.readFieldBegin()
7541 
      if ftype == TType.STOP:
7542 
        break
7543 
      if fid == 1:
7544 
        if ftype == TType.I64:
7545 
          self.vendorId = iprot.readI64();
7546 
        else:
7547 
          iprot.skip(ftype)
7548 
      else:
7549 
        iprot.skip(ftype)
7550 
      iprot.readFieldEnd()
7551 
    iprot.readStructEnd()
7552 
 
7553 
  def write(self, oprot):
7554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7556 
      return
7557 
    oprot.writeStructBegin('getVendor_args')
7558 
    if self.vendorId is not None:
7559 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
7560 
      oprot.writeI64(self.vendorId)
7561 
      oprot.writeFieldEnd()
7562 
    oprot.writeFieldStop()
7563 
    oprot.writeStructEnd()
7564 
 
7565 
  def validate(self):
7566 
    return
7567 
 
7568 
 
7569 
  def __repr__(self):
7570 
    L = ['%s=%r' % (key, value)
7571 
      for key, value in self.__dict__.iteritems()]
7572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7573 
 
7574 
  def __eq__(self, other):
7575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7576 
 
7577 
  def __ne__(self, other):
7578 
    return not (self == other)
7579 
 
7580 
class getVendor_result:
7581 
  """
7582 
  Attributes:
7583 
   - success
7584 
  """
7585 
 
7586 
  thrift_spec = (
7587 
    (0, TType.STRUCT, 'success', (Vendor, Vendor.thrift_spec), None, ), # 0
7588 
  )
7589 
 
7590 
  def __init__(self, success=None,):
7591 
    self.success = success
7592 
 
7593 
  def read(self, iprot):
7594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7596 
      return
7597 
    iprot.readStructBegin()
7598 
    while True:
7599 
      (fname, ftype, fid) = iprot.readFieldBegin()
7600 
      if ftype == TType.STOP:
7601 
        break
7602 
      if fid == 0:
7603 
        if ftype == TType.STRUCT:
7604 
          self.success = Vendor()
7605 
          self.success.read(iprot)
7606 
        else:
7607 
          iprot.skip(ftype)
7608 
      else:
7609 
        iprot.skip(ftype)
7610 
      iprot.readFieldEnd()
7611 
    iprot.readStructEnd()
7612 
 
7613 
  def write(self, oprot):
7614 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7615 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7616 
      return
7617 
    oprot.writeStructBegin('getVendor_result')
7618 
    if self.success is not None:
7619 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7620 
      self.success.write(oprot)
7621 
      oprot.writeFieldEnd()
7622 
    oprot.writeFieldStop()
7623 
    oprot.writeStructEnd()
7624 
 
7625 
  def validate(self):
7626 
    return
7627 
 
7628 
 
7629 
  def __repr__(self):
7630 
    L = ['%s=%r' % (key, value)
7631 
      for key, value in self.__dict__.iteritems()]
7632 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7633 
 
7634 
  def __eq__(self, other):
7635 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7636 
 
7637 
  def __ne__(self, other):
7638 
    return not (self == other)
7639 
 
7640 
class getAllVendors_args:
7641 
 
7642 
  thrift_spec = (
7643 
  )
7644 
 
7645 
  def read(self, iprot):
7646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7648 
      return
7649 
    iprot.readStructBegin()
7650 
    while True:
7651 
      (fname, ftype, fid) = iprot.readFieldBegin()
7652 
      if ftype == TType.STOP:
7653 
        break
7654 
      else:
7655 
        iprot.skip(ftype)
7656 
      iprot.readFieldEnd()
7657 
    iprot.readStructEnd()
7658 
 
7659 
  def write(self, oprot):
7660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7662 
      return
7663 
    oprot.writeStructBegin('getAllVendors_args')
7664 
    oprot.writeFieldStop()
7665 
    oprot.writeStructEnd()
7666 
 
7667 
  def validate(self):
7668 
    return
7669 
 
7670 
 
7671 
  def __repr__(self):
7672 
    L = ['%s=%r' % (key, value)
7673 
      for key, value in self.__dict__.iteritems()]
7674 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7675 
 
7676 
  def __eq__(self, other):
7677 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7678 
 
7679 
  def __ne__(self, other):
7680 
    return not (self == other)
7681 
 
7682 
class getAllVendors_result:
7683 
  """
7684 
  Attributes:
7685 
   - success
7686 
  """
7687 
 
7688 
  thrift_spec = (
7689 
    (0, TType.LIST, 'success', (TType.STRUCT,(Vendor, Vendor.thrift_spec)), None, ), # 0
7690 
  )
7691 
 
7692 
  def __init__(self, success=None,):
7693 
    self.success = success
7694 
 
7695 
  def read(self, iprot):
7696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7698 
      return
7699 
    iprot.readStructBegin()
7700 
    while True:
7701 
      (fname, ftype, fid) = iprot.readFieldBegin()
7702 
      if ftype == TType.STOP:
7703 
        break
7704 
      if fid == 0:
7705 
        if ftype == TType.LIST:
7706 
          self.success = []
8182 amar.kumar 7707 
          (_etype76, _size73) = iprot.readListBegin()
7708 
          for _i77 in xrange(_size73):
7709 
            _elem78 = Vendor()
7710 
            _elem78.read(iprot)
7711 
            self.success.append(_elem78)
5944 mandeep.dh 7712 
          iprot.readListEnd()
7713 
        else:
7714 
          iprot.skip(ftype)
7715 
      else:
7716 
        iprot.skip(ftype)
7717 
      iprot.readFieldEnd()
7718 
    iprot.readStructEnd()
7719 
 
7720 
  def write(self, oprot):
7721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7723 
      return
7724 
    oprot.writeStructBegin('getAllVendors_result')
7725 
    if self.success is not None:
7726 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7727 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 7728 
      for iter79 in self.success:
7729 
        iter79.write(oprot)
5944 mandeep.dh 7730 
      oprot.writeListEnd()
7731 
      oprot.writeFieldEnd()
7732 
    oprot.writeFieldStop()
7733 
    oprot.writeStructEnd()
7734 
 
7735 
  def validate(self):
7736 
    return
7737 
 
7738 
 
7739 
  def __repr__(self):
7740 
    L = ['%s=%r' % (key, value)
7741 
      for key, value in self.__dict__.iteritems()]
7742 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7743 
 
7744 
  def __eq__(self, other):
7745 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7746 
 
7747 
  def __ne__(self, other):
7748 
    return not (self == other)
7749 
 
7750 
class addVendorItemMapping_args:
7751 
  """
7752 
  Attributes:
7753 
   - key
7754 
   - vendorItemMapping
7755 
  """
7756 
 
7757 
  thrift_spec = (
7758 
    None, # 0
7759 
    (1, TType.STRING, 'key', None, None, ), # 1
7760 
    (2, TType.STRUCT, 'vendorItemMapping', (VendorItemMapping, VendorItemMapping.thrift_spec), None, ), # 2
7761 
  )
7762 
 
7763 
  def __init__(self, key=None, vendorItemMapping=None,):
7764 
    self.key = key
7765 
    self.vendorItemMapping = vendorItemMapping
7766 
 
7767 
  def read(self, iprot):
7768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7770 
      return
7771 
    iprot.readStructBegin()
7772 
    while True:
7773 
      (fname, ftype, fid) = iprot.readFieldBegin()
7774 
      if ftype == TType.STOP:
7775 
        break
7776 
      if fid == 1:
7777 
        if ftype == TType.STRING:
7778 
          self.key = iprot.readString();
7779 
        else:
7780 
          iprot.skip(ftype)
7781 
      elif fid == 2:
7782 
        if ftype == TType.STRUCT:
7783 
          self.vendorItemMapping = VendorItemMapping()
7784 
          self.vendorItemMapping.read(iprot)
7785 
        else:
7786 
          iprot.skip(ftype)
7787 
      else:
7788 
        iprot.skip(ftype)
7789 
      iprot.readFieldEnd()
7790 
    iprot.readStructEnd()
7791 
 
7792 
  def write(self, oprot):
7793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7795 
      return
7796 
    oprot.writeStructBegin('addVendorItemMapping_args')
7797 
    if self.key is not None:
7798 
      oprot.writeFieldBegin('key', TType.STRING, 1)
7799 
      oprot.writeString(self.key)
7800 
      oprot.writeFieldEnd()
7801 
    if self.vendorItemMapping is not None:
7802 
      oprot.writeFieldBegin('vendorItemMapping', TType.STRUCT, 2)
7803 
      self.vendorItemMapping.write(oprot)
7804 
      oprot.writeFieldEnd()
7805 
    oprot.writeFieldStop()
7806 
    oprot.writeStructEnd()
7807 
 
7808 
  def validate(self):
7809 
    return
7810 
 
7811 
 
7812 
  def __repr__(self):
7813 
    L = ['%s=%r' % (key, value)
7814 
      for key, value in self.__dict__.iteritems()]
7815 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7816 
 
7817 
  def __eq__(self, other):
7818 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7819 
 
7820 
  def __ne__(self, other):
7821 
    return not (self == other)
7822 
 
7823 
class addVendorItemMapping_result:
7824 
  """
7825 
  Attributes:
7826 
   - cex
7827 
  """
7828 
 
7829 
  thrift_spec = (
7830 
    None, # 0
7831 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
7832 
  )
7833 
 
7834 
  def __init__(self, cex=None,):
7835 
    self.cex = cex
7836 
 
7837 
  def read(self, iprot):
7838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7840 
      return
7841 
    iprot.readStructBegin()
7842 
    while True:
7843 
      (fname, ftype, fid) = iprot.readFieldBegin()
7844 
      if ftype == TType.STOP:
7845 
        break
7846 
      if fid == 1:
7847 
        if ftype == TType.STRUCT:
7848 
          self.cex = InventoryServiceException()
7849 
          self.cex.read(iprot)
7850 
        else:
7851 
          iprot.skip(ftype)
7852 
      else:
7853 
        iprot.skip(ftype)
7854 
      iprot.readFieldEnd()
7855 
    iprot.readStructEnd()
7856 
 
7857 
  def write(self, oprot):
7858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7860 
      return
7861 
    oprot.writeStructBegin('addVendorItemMapping_result')
7862 
    if self.cex is not None:
7863 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7864 
      self.cex.write(oprot)
7865 
      oprot.writeFieldEnd()
7866 
    oprot.writeFieldStop()
7867 
    oprot.writeStructEnd()
7868 
 
7869 
  def validate(self):
7870 
    return
7871 
 
7872 
 
7873 
  def __repr__(self):
7874 
    L = ['%s=%r' % (key, value)
7875 
      for key, value in self.__dict__.iteritems()]
7876 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7877 
 
7878 
  def __eq__(self, other):
7879 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7880 
 
7881 
  def __ne__(self, other):
7882 
    return not (self == other)
7883 
 
7884 
class getVendorItemMappings_args:
7885 
  """
7886 
  Attributes:
7887 
   - itemId
7888 
  """
7889 
 
7890 
  thrift_spec = (
7891 
    None, # 0
7892 
    (1, TType.I64, 'itemId', None, None, ), # 1
7893 
  )
7894 
 
7895 
  def __init__(self, itemId=None,):
7896 
    self.itemId = itemId
7897 
 
7898 
  def read(self, iprot):
7899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7901 
      return
7902 
    iprot.readStructBegin()
7903 
    while True:
7904 
      (fname, ftype, fid) = iprot.readFieldBegin()
7905 
      if ftype == TType.STOP:
7906 
        break
7907 
      if fid == 1:
7908 
        if ftype == TType.I64:
7909 
          self.itemId = iprot.readI64();
7910 
        else:
7911 
          iprot.skip(ftype)
7912 
      else:
7913 
        iprot.skip(ftype)
7914 
      iprot.readFieldEnd()
7915 
    iprot.readStructEnd()
7916 
 
7917 
  def write(self, oprot):
7918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7920 
      return
7921 
    oprot.writeStructBegin('getVendorItemMappings_args')
7922 
    if self.itemId is not None:
7923 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
7924 
      oprot.writeI64(self.itemId)
7925 
      oprot.writeFieldEnd()
7926 
    oprot.writeFieldStop()
7927 
    oprot.writeStructEnd()
7928 
 
7929 
  def validate(self):
7930 
    return
7931 
 
7932 
 
7933 
  def __repr__(self):
7934 
    L = ['%s=%r' % (key, value)
7935 
      for key, value in self.__dict__.iteritems()]
7936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7937 
 
7938 
  def __eq__(self, other):
7939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7940 
 
7941 
  def __ne__(self, other):
7942 
    return not (self == other)
7943 
 
7944 
class getVendorItemMappings_result:
7945 
  """
7946 
  Attributes:
7947 
   - success
7948 
   - cex
7949 
  """
7950 
 
7951 
  thrift_spec = (
7952 
    (0, TType.LIST, 'success', (TType.STRUCT,(VendorItemMapping, VendorItemMapping.thrift_spec)), None, ), # 0
7953 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
7954 
  )
7955 
 
7956 
  def __init__(self, success=None, cex=None,):
7957 
    self.success = success
7958 
    self.cex = cex
7959 
 
7960 
  def read(self, iprot):
7961 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7962 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7963 
      return
7964 
    iprot.readStructBegin()
7965 
    while True:
7966 
      (fname, ftype, fid) = iprot.readFieldBegin()
7967 
      if ftype == TType.STOP:
7968 
        break
7969 
      if fid == 0:
7970 
        if ftype == TType.LIST:
7971 
          self.success = []
8182 amar.kumar 7972 
          (_etype83, _size80) = iprot.readListBegin()
7973 
          for _i84 in xrange(_size80):
7974 
            _elem85 = VendorItemMapping()
7975 
            _elem85.read(iprot)
7976 
            self.success.append(_elem85)
5944 mandeep.dh 7977 
          iprot.readListEnd()
7978 
        else:
7979 
          iprot.skip(ftype)
7980 
      elif fid == 1:
7981 
        if ftype == TType.STRUCT:
7982 
          self.cex = InventoryServiceException()
7983 
          self.cex.read(iprot)
7984 
        else:
7985 
          iprot.skip(ftype)
7986 
      else:
7987 
        iprot.skip(ftype)
7988 
      iprot.readFieldEnd()
7989 
    iprot.readStructEnd()
7990 
 
7991 
  def write(self, oprot):
7992 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7993 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7994 
      return
7995 
    oprot.writeStructBegin('getVendorItemMappings_result')
7996 
    if self.success is not None:
7997 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7998 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 7999 
      for iter86 in self.success:
8000 
        iter86.write(oprot)
5944 mandeep.dh 8001 
      oprot.writeListEnd()
8002 
      oprot.writeFieldEnd()
8003 
    if self.cex is not None:
8004 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8005 
      self.cex.write(oprot)
8006 
      oprot.writeFieldEnd()
8007 
    oprot.writeFieldStop()
8008 
    oprot.writeStructEnd()
8009 
 
8010 
  def validate(self):
8011 
    return
8012 
 
8013 
 
8014 
  def __repr__(self):
8015 
    L = ['%s=%r' % (key, value)
8016 
      for key, value in self.__dict__.iteritems()]
8017 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8018 
 
8019 
  def __eq__(self, other):
8020 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8021 
 
8022 
  def __ne__(self, other):
8023 
    return not (self == other)
8024 
 
8025 
class getPendingOrdersInventory_args:
8026 
  """
8027 
  Attributes:
8028 
   - vendorid
8029 
  """
8030 
 
8031 
  thrift_spec = (
8032 
    None, # 0
8033 
    (1, TType.I64, 'vendorid', None, None, ), # 1
8034 
  )
8035 
 
8036 
  def __init__(self, vendorid=None,):
8037 
    self.vendorid = vendorid
8038 
 
8039 
  def read(self, iprot):
8040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8042 
      return
8043 
    iprot.readStructBegin()
8044 
    while True:
8045 
      (fname, ftype, fid) = iprot.readFieldBegin()
8046 
      if ftype == TType.STOP:
8047 
        break
8048 
      if fid == 1:
8049 
        if ftype == TType.I64:
8050 
          self.vendorid = iprot.readI64();
8051 
        else:
8052 
          iprot.skip(ftype)
8053 
      else:
8054 
        iprot.skip(ftype)
8055 
      iprot.readFieldEnd()
8056 
    iprot.readStructEnd()
8057 
 
8058 
  def write(self, oprot):
8059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8061 
      return
8062 
    oprot.writeStructBegin('getPendingOrdersInventory_args')
8063 
    if self.vendorid is not None:
8064 
      oprot.writeFieldBegin('vendorid', TType.I64, 1)
8065 
      oprot.writeI64(self.vendorid)
8066 
      oprot.writeFieldEnd()
8067 
    oprot.writeFieldStop()
8068 
    oprot.writeStructEnd()
8069 
 
8070 
  def validate(self):
8071 
    return
8072 
 
8073 
 
8074 
  def __repr__(self):
8075 
    L = ['%s=%r' % (key, value)
8076 
      for key, value in self.__dict__.iteritems()]
8077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8078 
 
8079 
  def __eq__(self, other):
8080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8081 
 
8082 
  def __ne__(self, other):
8083 
    return not (self == other)
8084 
 
8085 
class getPendingOrdersInventory_result:
8086 
  """
8087 
  Attributes:
8088 
   - success
8089 
  """
8090 
 
8091 
  thrift_spec = (
8092 
    (0, TType.LIST, 'success', (TType.STRUCT,(AvailableAndReservedStock, AvailableAndReservedStock.thrift_spec)), None, ), # 0
8093 
  )
8094 
 
8095 
  def __init__(self, success=None,):
8096 
    self.success = success
8097 
 
8098 
  def read(self, iprot):
8099 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8100 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8101 
      return
8102 
    iprot.readStructBegin()
8103 
    while True:
8104 
      (fname, ftype, fid) = iprot.readFieldBegin()
8105 
      if ftype == TType.STOP:
8106 
        break
8107 
      if fid == 0:
8108 
        if ftype == TType.LIST:
8109 
          self.success = []
8182 amar.kumar 8110 
          (_etype90, _size87) = iprot.readListBegin()
8111 
          for _i91 in xrange(_size87):
8112 
            _elem92 = AvailableAndReservedStock()
8113 
            _elem92.read(iprot)
8114 
            self.success.append(_elem92)
5944 mandeep.dh 8115 
          iprot.readListEnd()
8116 
        else:
8117 
          iprot.skip(ftype)
8118 
      else:
8119 
        iprot.skip(ftype)
8120 
      iprot.readFieldEnd()
8121 
    iprot.readStructEnd()
8122 
 
8123 
  def write(self, oprot):
8124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8126 
      return
8127 
    oprot.writeStructBegin('getPendingOrdersInventory_result')
8128 
    if self.success is not None:
8129 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8130 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 8131 
      for iter93 in self.success:
8132 
        iter93.write(oprot)
5944 mandeep.dh 8133 
      oprot.writeListEnd()
8134 
      oprot.writeFieldEnd()
8135 
    oprot.writeFieldStop()
8136 
    oprot.writeStructEnd()
8137 
 
8138 
  def validate(self):
8139 
    return
8140 
 
8141 
 
8142 
  def __repr__(self):
8143 
    L = ['%s=%r' % (key, value)
8144 
      for key, value in self.__dict__.iteritems()]
8145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8146 
 
8147 
  def __eq__(self, other):
8148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8149 
 
8150 
  def __ne__(self, other):
8151 
    return not (self == other)
8152 
 
8153 
class getWarehouses_args:
8154 
  """
8155 
  Attributes:
8156 
   - warehouseType
8157 
   - inventoryType
8158 
   - vendorId
8159 
   - billingWarehouseId
8160 
   - shippingWarehouseId
8161 
  """
8162 
 
8163 
  thrift_spec = (
8164 
    None, # 0
8165 
    (1, TType.I32, 'warehouseType', None, None, ), # 1
8166 
    (2, TType.I32, 'inventoryType', None, None, ), # 2
8167 
    (3, TType.I64, 'vendorId', None, None, ), # 3
8168 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
8169 
    (5, TType.I64, 'shippingWarehouseId', None, None, ), # 5
8170 
  )
8171 
 
8172 
  def __init__(self, warehouseType=None, inventoryType=None, vendorId=None, billingWarehouseId=None, shippingWarehouseId=None,):
8173 
    self.warehouseType = warehouseType
8174 
    self.inventoryType = inventoryType
8175 
    self.vendorId = vendorId
8176 
    self.billingWarehouseId = billingWarehouseId
8177 
    self.shippingWarehouseId = shippingWarehouseId
8178 
 
8179 
  def read(self, iprot):
8180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8182 
      return
8183 
    iprot.readStructBegin()
8184 
    while True:
8185 
      (fname, ftype, fid) = iprot.readFieldBegin()
8186 
      if ftype == TType.STOP:
8187 
        break
8188 
      if fid == 1:
8189 
        if ftype == TType.I32:
8190 
          self.warehouseType = iprot.readI32();
8191 
        else:
8192 
          iprot.skip(ftype)
8193 
      elif fid == 2:
8194 
        if ftype == TType.I32:
8195 
          self.inventoryType = iprot.readI32();
8196 
        else:
8197 
          iprot.skip(ftype)
8198 
      elif fid == 3:
8199 
        if ftype == TType.I64:
8200 
          self.vendorId = iprot.readI64();
8201 
        else:
8202 
          iprot.skip(ftype)
8203 
      elif fid == 4:
8204 
        if ftype == TType.I64:
8205 
          self.billingWarehouseId = iprot.readI64();
8206 
        else:
8207 
          iprot.skip(ftype)
8208 
      elif fid == 5:
8209 
        if ftype == TType.I64:
8210 
          self.shippingWarehouseId = iprot.readI64();
8211 
        else:
8212 
          iprot.skip(ftype)
8213 
      else:
8214 
        iprot.skip(ftype)
8215 
      iprot.readFieldEnd()
8216 
    iprot.readStructEnd()
8217 
 
8218 
  def write(self, oprot):
8219 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8220 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8221 
      return
8222 
    oprot.writeStructBegin('getWarehouses_args')
8223 
    if self.warehouseType is not None:
8224 
      oprot.writeFieldBegin('warehouseType', TType.I32, 1)
8225 
      oprot.writeI32(self.warehouseType)
8226 
      oprot.writeFieldEnd()
8227 
    if self.inventoryType is not None:
8228 
      oprot.writeFieldBegin('inventoryType', TType.I32, 2)
8229 
      oprot.writeI32(self.inventoryType)
8230 
      oprot.writeFieldEnd()
8231 
    if self.vendorId is not None:
8232 
      oprot.writeFieldBegin('vendorId', TType.I64, 3)
8233 
      oprot.writeI64(self.vendorId)
8234 
      oprot.writeFieldEnd()
8235 
    if self.billingWarehouseId is not None:
8236 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
8237 
      oprot.writeI64(self.billingWarehouseId)
8238 
      oprot.writeFieldEnd()
8239 
    if self.shippingWarehouseId is not None:
8240 
      oprot.writeFieldBegin('shippingWarehouseId', TType.I64, 5)
8241 
      oprot.writeI64(self.shippingWarehouseId)
8242 
      oprot.writeFieldEnd()
8243 
    oprot.writeFieldStop()
8244 
    oprot.writeStructEnd()
8245 
 
8246 
  def validate(self):
8247 
    return
8248 
 
8249 
 
8250 
  def __repr__(self):
8251 
    L = ['%s=%r' % (key, value)
8252 
      for key, value in self.__dict__.iteritems()]
8253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8254 
 
8255 
  def __eq__(self, other):
8256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8257 
 
8258 
  def __ne__(self, other):
8259 
    return not (self == other)
8260 
 
8261 
class getWarehouses_result:
8262 
  """
8263 
  Attributes:
8264 
   - success
8265 
  """
8266 
 
8267 
  thrift_spec = (
8268 
    (0, TType.LIST, 'success', (TType.STRUCT,(Warehouse, Warehouse.thrift_spec)), None, ), # 0
8269 
  )
8270 
 
8271 
  def __init__(self, success=None,):
8272 
    self.success = success
8273 
 
8274 
  def read(self, iprot):
8275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8277 
      return
8278 
    iprot.readStructBegin()
8279 
    while True:
8280 
      (fname, ftype, fid) = iprot.readFieldBegin()
8281 
      if ftype == TType.STOP:
8282 
        break
8283 
      if fid == 0:
8284 
        if ftype == TType.LIST:
8285 
          self.success = []
8182 amar.kumar 8286 
          (_etype97, _size94) = iprot.readListBegin()
8287 
          for _i98 in xrange(_size94):
8288 
            _elem99 = Warehouse()
8289 
            _elem99.read(iprot)
8290 
            self.success.append(_elem99)
5944 mandeep.dh 8291 
          iprot.readListEnd()
8292 
        else:
8293 
          iprot.skip(ftype)
8294 
      else:
8295 
        iprot.skip(ftype)
8296 
      iprot.readFieldEnd()
8297 
    iprot.readStructEnd()
8298 
 
8299 
  def write(self, oprot):
8300 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8301 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8302 
      return
8303 
    oprot.writeStructBegin('getWarehouses_result')
8304 
    if self.success is not None:
8305 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8306 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 8307 
      for iter100 in self.success:
8308 
        iter100.write(oprot)
5944 mandeep.dh 8309 
      oprot.writeListEnd()
8310 
      oprot.writeFieldEnd()
8311 
    oprot.writeFieldStop()
8312 
    oprot.writeStructEnd()
8313 
 
8314 
  def validate(self):
8315 
    return
8316 
 
8317 
 
8318 
  def __repr__(self):
8319 
    L = ['%s=%r' % (key, value)
8320 
      for key, value in self.__dict__.iteritems()]
8321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8322 
 
8323 
  def __eq__(self, other):
8324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8325 
 
8326 
  def __ne__(self, other):
8327 
    return not (self == other)
8328 
 
8329 
class resetAvailability_args:
8330 
  """
8331 
  Attributes:
8332 
   - itemKey
8333 
   - vendorId
8334 
   - quantity
8335 
   - warehouseId
8336 
  """
8337 
 
8338 
  thrift_spec = (
8339 
    None, # 0
8340 
    (1, TType.STRING, 'itemKey', None, None, ), # 1
8341 
    (2, TType.I64, 'vendorId', None, None, ), # 2
8342 
    (3, TType.I64, 'quantity', None, None, ), # 3
8343 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
8344 
  )
8345 
 
8346 
  def __init__(self, itemKey=None, vendorId=None, quantity=None, warehouseId=None,):
8347 
    self.itemKey = itemKey
8348 
    self.vendorId = vendorId
8349 
    self.quantity = quantity
8350 
    self.warehouseId = warehouseId
8351 
 
8352 
  def read(self, iprot):
8353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8355 
      return
8356 
    iprot.readStructBegin()
8357 
    while True:
8358 
      (fname, ftype, fid) = iprot.readFieldBegin()
8359 
      if ftype == TType.STOP:
8360 
        break
8361 
      if fid == 1:
8362 
        if ftype == TType.STRING:
8363 
          self.itemKey = iprot.readString();
8364 
        else:
8365 
          iprot.skip(ftype)
8366 
      elif fid == 2:
8367 
        if ftype == TType.I64:
8368 
          self.vendorId = iprot.readI64();
8369 
        else:
8370 
          iprot.skip(ftype)
8371 
      elif fid == 3:
8372 
        if ftype == TType.I64:
8373 
          self.quantity = iprot.readI64();
8374 
        else:
8375 
          iprot.skip(ftype)
8376 
      elif fid == 4:
8377 
        if ftype == TType.I64:
8378 
          self.warehouseId = iprot.readI64();
8379 
        else:
8380 
          iprot.skip(ftype)
8381 
      else:
8382 
        iprot.skip(ftype)
8383 
      iprot.readFieldEnd()
8384 
    iprot.readStructEnd()
8385 
 
8386 
  def write(self, oprot):
8387 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8388 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8389 
      return
8390 
    oprot.writeStructBegin('resetAvailability_args')
8391 
    if self.itemKey is not None:
8392 
      oprot.writeFieldBegin('itemKey', TType.STRING, 1)
8393 
      oprot.writeString(self.itemKey)
8394 
      oprot.writeFieldEnd()
8395 
    if self.vendorId is not None:
8396 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
8397 
      oprot.writeI64(self.vendorId)
8398 
      oprot.writeFieldEnd()
8399 
    if self.quantity is not None:
8400 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
8401 
      oprot.writeI64(self.quantity)
8402 
      oprot.writeFieldEnd()
8403 
    if self.warehouseId is not None:
8404 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
8405 
      oprot.writeI64(self.warehouseId)
8406 
      oprot.writeFieldEnd()
8407 
    oprot.writeFieldStop()
8408 
    oprot.writeStructEnd()
8409 
 
8410 
  def validate(self):
8411 
    return
8412 
 
8413 
 
8414 
  def __repr__(self):
8415 
    L = ['%s=%r' % (key, value)
8416 
      for key, value in self.__dict__.iteritems()]
8417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8418 
 
8419 
  def __eq__(self, other):
8420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8421 
 
8422 
  def __ne__(self, other):
8423 
    return not (self == other)
8424 
 
8425 
class resetAvailability_result:
8426 
  """
8427 
  Attributes:
8428 
   - cex
8429 
  """
8430 
 
8431 
  thrift_spec = (
8432 
    None, # 0
8433 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
8434 
  )
8435 
 
8436 
  def __init__(self, cex=None,):
8437 
    self.cex = cex
8438 
 
8439 
  def read(self, iprot):
8440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8442 
      return
8443 
    iprot.readStructBegin()
8444 
    while True:
8445 
      (fname, ftype, fid) = iprot.readFieldBegin()
8446 
      if ftype == TType.STOP:
8447 
        break
8448 
      if fid == 1:
8449 
        if ftype == TType.STRUCT:
8450 
          self.cex = InventoryServiceException()
8451 
          self.cex.read(iprot)
8452 
        else:
8453 
          iprot.skip(ftype)
8454 
      else:
8455 
        iprot.skip(ftype)
8456 
      iprot.readFieldEnd()
8457 
    iprot.readStructEnd()
8458 
 
8459 
  def write(self, oprot):
8460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8462 
      return
8463 
    oprot.writeStructBegin('resetAvailability_result')
8464 
    if self.cex is not None:
8465 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8466 
      self.cex.write(oprot)
8467 
      oprot.writeFieldEnd()
8468 
    oprot.writeFieldStop()
8469 
    oprot.writeStructEnd()
8470 
 
8471 
  def validate(self):
8472 
    return
8473 
 
8474 
 
8475 
  def __repr__(self):
8476 
    L = ['%s=%r' % (key, value)
8477 
      for key, value in self.__dict__.iteritems()]
8478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8479 
 
8480 
  def __eq__(self, other):
8481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8482 
 
8483 
  def __ne__(self, other):
8484 
    return not (self == other)
8485 
 
8486 
class resetAvailabilityForWarehouse_args:
8487 
  """
8488 
  Attributes:
8489 
   - warehouseId
8490 
  """
8491 
 
8492 
  thrift_spec = (
8493 
    None, # 0
8494 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8495 
  )
8496 
 
8497 
  def __init__(self, warehouseId=None,):
8498 
    self.warehouseId = warehouseId
8499 
 
8500 
  def read(self, iprot):
8501 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8502 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8503 
      return
8504 
    iprot.readStructBegin()
8505 
    while True:
8506 
      (fname, ftype, fid) = iprot.readFieldBegin()
8507 
      if ftype == TType.STOP:
8508 
        break
8509 
      if fid == 1:
8510 
        if ftype == TType.I64:
8511 
          self.warehouseId = iprot.readI64();
8512 
        else:
8513 
          iprot.skip(ftype)
8514 
      else:
8515 
        iprot.skip(ftype)
8516 
      iprot.readFieldEnd()
8517 
    iprot.readStructEnd()
8518 
 
8519 
  def write(self, oprot):
8520 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8521 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8522 
      return
8523 
    oprot.writeStructBegin('resetAvailabilityForWarehouse_args')
8524 
    if self.warehouseId is not None:
8525 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8526 
      oprot.writeI64(self.warehouseId)
8527 
      oprot.writeFieldEnd()
8528 
    oprot.writeFieldStop()
8529 
    oprot.writeStructEnd()
8530 
 
8531 
  def validate(self):
8532 
    return
8533 
 
8534 
 
8535 
  def __repr__(self):
8536 
    L = ['%s=%r' % (key, value)
8537 
      for key, value in self.__dict__.iteritems()]
8538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8539 
 
8540 
  def __eq__(self, other):
8541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8542 
 
8543 
  def __ne__(self, other):
8544 
    return not (self == other)
8545 
 
8546 
class resetAvailabilityForWarehouse_result:
8547 
  """
8548 
  Attributes:
8549 
   - cex
8550 
  """
8551 
 
8552 
  thrift_spec = (
8553 
    None, # 0
8554 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
8555 
  )
8556 
 
8557 
  def __init__(self, cex=None,):
8558 
    self.cex = cex
8559 
 
8560 
  def read(self, iprot):
8561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8563 
      return
8564 
    iprot.readStructBegin()
8565 
    while True:
8566 
      (fname, ftype, fid) = iprot.readFieldBegin()
8567 
      if ftype == TType.STOP:
8568 
        break
8569 
      if fid == 1:
8570 
        if ftype == TType.STRUCT:
8571 
          self.cex = InventoryServiceException()
8572 
          self.cex.read(iprot)
8573 
        else:
8574 
          iprot.skip(ftype)
8575 
      else:
8576 
        iprot.skip(ftype)
8577 
      iprot.readFieldEnd()
8578 
    iprot.readStructEnd()
8579 
 
8580 
  def write(self, oprot):
8581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8583 
      return
8584 
    oprot.writeStructBegin('resetAvailabilityForWarehouse_result')
8585 
    if self.cex is not None:
8586 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8587 
      self.cex.write(oprot)
8588 
      oprot.writeFieldEnd()
8589 
    oprot.writeFieldStop()
8590 
    oprot.writeStructEnd()
8591 
 
8592 
  def validate(self):
8593 
    return
8594 
 
8595 
 
8596 
  def __repr__(self):
8597 
    L = ['%s=%r' % (key, value)
8598 
      for key, value in self.__dict__.iteritems()]
8599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8600 
 
8601 
  def __eq__(self, other):
8602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8603 
 
8604 
  def __ne__(self, other):
8605 
    return not (self == other)
8606 
 
8607 
class getItemKeysToBeProcessed_args:
8608 
  """
8609 
  Attributes:
8610 
   - warehouseId
8611 
  """
8612 
 
8613 
  thrift_spec = (
8614 
    None, # 0
8615 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8616 
  )
8617 
 
8618 
  def __init__(self, warehouseId=None,):
8619 
    self.warehouseId = warehouseId
8620 
 
8621 
  def read(self, iprot):
8622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8624 
      return
8625 
    iprot.readStructBegin()
8626 
    while True:
8627 
      (fname, ftype, fid) = iprot.readFieldBegin()
8628 
      if ftype == TType.STOP:
8629 
        break
8630 
      if fid == 1:
8631 
        if ftype == TType.I64:
8632 
          self.warehouseId = iprot.readI64();
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_args')
8645 
    if self.warehouseId is not None:
8646 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8647 
      oprot.writeI64(self.warehouseId)
8648 
      oprot.writeFieldEnd()
8649 
    oprot.writeFieldStop()
8650 
    oprot.writeStructEnd()
8651 
 
8652 
  def validate(self):
8653 
    return
8654 
 
8655 
 
8656 
  def __repr__(self):
8657 
    L = ['%s=%r' % (key, value)
8658 
      for key, value in self.__dict__.iteritems()]
8659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8660 
 
8661 
  def __eq__(self, other):
8662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8663 
 
8664 
  def __ne__(self, other):
8665 
    return not (self == other)
8666 
 
8667 
class getItemKeysToBeProcessed_result:
8668 
  """
8669 
  Attributes:
8670 
   - success
8671 
  """
8672 
 
8673 
  thrift_spec = (
8674 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
8675 
  )
8676 
 
8677 
  def __init__(self, success=None,):
8678 
    self.success = success
8679 
 
8680 
  def read(self, iprot):
8681 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8682 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8683 
      return
8684 
    iprot.readStructBegin()
8685 
    while True:
8686 
      (fname, ftype, fid) = iprot.readFieldBegin()
8687 
      if ftype == TType.STOP:
8688 
        break
8689 
      if fid == 0:
8690 
        if ftype == TType.LIST:
8691 
          self.success = []
8182 amar.kumar 8692 
          (_etype104, _size101) = iprot.readListBegin()
8693 
          for _i105 in xrange(_size101):
8694 
            _elem106 = iprot.readString();
8695 
            self.success.append(_elem106)
5944 mandeep.dh 8696 
          iprot.readListEnd()
8697 
        else:
8698 
          iprot.skip(ftype)
8699 
      else:
8700 
        iprot.skip(ftype)
8701 
      iprot.readFieldEnd()
8702 
    iprot.readStructEnd()
8703 
 
8704 
  def write(self, oprot):
8705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8707 
      return
8708 
    oprot.writeStructBegin('getItemKeysToBeProcessed_result')
8709 
    if self.success is not None:
8710 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8711 
      oprot.writeListBegin(TType.STRING, len(self.success))
8182 amar.kumar 8712 
      for iter107 in self.success:
8713 
        oprot.writeString(iter107)
5944 mandeep.dh 8714 
      oprot.writeListEnd()
8715 
      oprot.writeFieldEnd()
8716 
    oprot.writeFieldStop()
8717 
    oprot.writeStructEnd()
8718 
 
8719 
  def validate(self):
8720 
    return
8721 
 
8722 
 
8723 
  def __repr__(self):
8724 
    L = ['%s=%r' % (key, value)
8725 
      for key, value in self.__dict__.iteritems()]
8726 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8727 
 
8728 
  def __eq__(self, other):
8729 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8730 
 
8731 
  def __ne__(self, other):
8732 
    return not (self == other)
8733 
 
8734 
class markMissedInventoryUpdatesAsProcessed_args:
8735 
  """
8736 
  Attributes:
8737 
   - itemKey
8738 
   - warehouseId
8739 
  """
8740 
 
8741 
  thrift_spec = (
8742 
    None, # 0
8743 
    (1, TType.STRING, 'itemKey', None, None, ), # 1
8744 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8745 
  )
8746 
 
8747 
  def __init__(self, itemKey=None, warehouseId=None,):
8748 
    self.itemKey = itemKey
8749 
    self.warehouseId = warehouseId
8750 
 
8751 
  def read(self, iprot):
8752 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8753 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8754 
      return
8755 
    iprot.readStructBegin()
8756 
    while True:
8757 
      (fname, ftype, fid) = iprot.readFieldBegin()
8758 
      if ftype == TType.STOP:
8759 
        break
8760 
      if fid == 1:
8761 
        if ftype == TType.STRING:
8762 
          self.itemKey = iprot.readString();
8763 
        else:
8764 
          iprot.skip(ftype)
8765 
      elif fid == 2:
8766 
        if ftype == TType.I64:
8767 
          self.warehouseId = iprot.readI64();
8768 
        else:
8769 
          iprot.skip(ftype)
8770 
      else:
8771 
        iprot.skip(ftype)
8772 
      iprot.readFieldEnd()
8773 
    iprot.readStructEnd()
8774 
 
8775 
  def write(self, oprot):
8776 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8777 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8778 
      return
8779 
    oprot.writeStructBegin('markMissedInventoryUpdatesAsProcessed_args')
8780 
    if self.itemKey is not None:
8781 
      oprot.writeFieldBegin('itemKey', TType.STRING, 1)
8782 
      oprot.writeString(self.itemKey)
8783 
      oprot.writeFieldEnd()
8784 
    if self.warehouseId is not None:
8785 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8786 
      oprot.writeI64(self.warehouseId)
8787 
      oprot.writeFieldEnd()
8788 
    oprot.writeFieldStop()
8789 
    oprot.writeStructEnd()
8790 
 
8791 
  def validate(self):
8792 
    return
8793 
 
8794 
 
8795 
  def __repr__(self):
8796 
    L = ['%s=%r' % (key, value)
8797 
      for key, value in self.__dict__.iteritems()]
8798 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8799 
 
8800 
  def __eq__(self, other):
8801 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8802 
 
8803 
  def __ne__(self, other):
8804 
    return not (self == other)
8805 
 
8806 
class markMissedInventoryUpdatesAsProcessed_result:
8807 
 
8808 
  thrift_spec = (
8809 
  )
8810 
 
8811 
  def read(self, iprot):
8812 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8813 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8814 
      return
8815 
    iprot.readStructBegin()
8816 
    while True:
8817 
      (fname, ftype, fid) = iprot.readFieldBegin()
8818 
      if ftype == TType.STOP:
8819 
        break
8820 
      else:
8821 
        iprot.skip(ftype)
8822 
      iprot.readFieldEnd()
8823 
    iprot.readStructEnd()
8824 
 
8825 
  def write(self, oprot):
8826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8828 
      return
8829 
    oprot.writeStructBegin('markMissedInventoryUpdatesAsProcessed_result')
8830 
    oprot.writeFieldStop()
8831 
    oprot.writeStructEnd()
8832 
 
8833 
  def validate(self):
8834 
    return
8835 
 
8836 
 
8837 
  def __repr__(self):
8838 
    L = ['%s=%r' % (key, value)
8839 
      for key, value in self.__dict__.iteritems()]
8840 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8841 
 
8842 
  def __eq__(self, other):
8843 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8844 
 
8845 
  def __ne__(self, other):
8846 
    return not (self == other)
8847 
 
8848 
class getIgnoredItemKeys_args:
8849 
 
8850 
  thrift_spec = (
8851 
  )
8852 
 
8853 
  def read(self, iprot):
8854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8856 
      return
8857 
    iprot.readStructBegin()
8858 
    while True:
8859 
      (fname, ftype, fid) = iprot.readFieldBegin()
8860 
      if ftype == TType.STOP:
8861 
        break
8862 
      else:
8863 
        iprot.skip(ftype)
8864 
      iprot.readFieldEnd()
8865 
    iprot.readStructEnd()
8866 
 
8867 
  def write(self, oprot):
8868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8870 
      return
8871 
    oprot.writeStructBegin('getIgnoredItemKeys_args')
8872 
    oprot.writeFieldStop()
8873 
    oprot.writeStructEnd()
8874 
 
8875 
  def validate(self):
8876 
    return
8877 
 
8878 
 
8879 
  def __repr__(self):
8880 
    L = ['%s=%r' % (key, value)
8881 
      for key, value in self.__dict__.iteritems()]
8882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8883 
 
8884 
  def __eq__(self, other):
8885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8886 
 
8887 
  def __ne__(self, other):
8888 
    return not (self == other)
8889 
 
8890 
class getIgnoredItemKeys_result:
8891 
  """
8892 
  Attributes:
8893 
   - success
8894 
  """
8895 
 
8896 
  thrift_spec = (
8897 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.MAP,(TType.I64,None,TType.I64,None)), None, ), # 0
8898 
  )
8899 
 
8900 
  def __init__(self, success=None,):
8901 
    self.success = success
8902 
 
8903 
  def read(self, iprot):
8904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8906 
      return
8907 
    iprot.readStructBegin()
8908 
    while True:
8909 
      (fname, ftype, fid) = iprot.readFieldBegin()
8910 
      if ftype == TType.STOP:
8911 
        break
8912 
      if fid == 0:
8913 
        if ftype == TType.MAP:
8914 
          self.success = {}
8182 amar.kumar 8915 
          (_ktype109, _vtype110, _size108 ) = iprot.readMapBegin()
8916 
          for _i112 in xrange(_size108):
8917 
            _key113 = iprot.readString();
8918 
            _val114 = {}
8919 
            (_ktype116, _vtype117, _size115 ) = iprot.readMapBegin()
8920 
            for _i119 in xrange(_size115):
8921 
              _key120 = iprot.readI64();
8922 
              _val121 = iprot.readI64();
8923 
              _val114[_key120] = _val121
5944 mandeep.dh 8924 
            iprot.readMapEnd()
8182 amar.kumar 8925 
            self.success[_key113] = _val114
5944 mandeep.dh 8926 
          iprot.readMapEnd()
8927 
        else:
8928 
          iprot.skip(ftype)
8929 
      else:
8930 
        iprot.skip(ftype)
8931 
      iprot.readFieldEnd()
8932 
    iprot.readStructEnd()
8933 
 
8934 
  def write(self, oprot):
8935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8937 
      return
8938 
    oprot.writeStructBegin('getIgnoredItemKeys_result')
8939 
    if self.success is not None:
8940 
      oprot.writeFieldBegin('success', TType.MAP, 0)
8941 
      oprot.writeMapBegin(TType.STRING, TType.MAP, len(self.success))
8182 amar.kumar 8942 
      for kiter122,viter123 in self.success.items():
8943 
        oprot.writeString(kiter122)
8944 
        oprot.writeMapBegin(TType.I64, TType.I64, len(viter123))
8945 
        for kiter124,viter125 in viter123.items():
8946 
          oprot.writeI64(kiter124)
8947 
          oprot.writeI64(viter125)
5944 mandeep.dh 8948 
        oprot.writeMapEnd()
8949 
      oprot.writeMapEnd()
8950 
      oprot.writeFieldEnd()
8951 
    oprot.writeFieldStop()
8952 
    oprot.writeStructEnd()
8953 
 
8954 
  def validate(self):
8955 
    return
8956 
 
8957 
 
8958 
  def __repr__(self):
8959 
    L = ['%s=%r' % (key, value)
8960 
      for key, value in self.__dict__.iteritems()]
8961 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8962 
 
8963 
  def __eq__(self, other):
8964 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8965 
 
8966 
  def __ne__(self, other):
8967 
    return not (self == other)
8968 
 
8969 
class addBadInventory_args:
8970 
  """
8971 
  Attributes:
8972 
   - itemId
8973 
   - warehouseId
8974 
   - quantity
8975 
  """
8976 
 
8977 
  thrift_spec = (
8978 
    None, # 0
8979 
    (1, TType.I64, 'itemId', None, None, ), # 1
8980 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8981 
    (3, TType.I64, 'quantity', None, None, ), # 3
8982 
  )
8983 
 
8984 
  def __init__(self, itemId=None, warehouseId=None, quantity=None,):
8985 
    self.itemId = itemId
8986 
    self.warehouseId = warehouseId
8987 
    self.quantity = quantity
8988 
 
8989 
  def read(self, iprot):
8990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8992 
      return
8993 
    iprot.readStructBegin()
8994 
    while True:
8995 
      (fname, ftype, fid) = iprot.readFieldBegin()
8996 
      if ftype == TType.STOP:
8997 
        break
8998 
      if fid == 1:
8999 
        if ftype == TType.I64:
9000 
          self.itemId = iprot.readI64();
9001 
        else:
9002 
          iprot.skip(ftype)
9003 
      elif fid == 2:
9004 
        if ftype == TType.I64:
9005 
          self.warehouseId = iprot.readI64();
9006 
        else:
9007 
          iprot.skip(ftype)
9008 
      elif fid == 3:
9009 
        if ftype == TType.I64:
9010 
          self.quantity = iprot.readI64();
9011 
        else:
9012 
          iprot.skip(ftype)
9013 
      else:
9014 
        iprot.skip(ftype)
9015 
      iprot.readFieldEnd()
9016 
    iprot.readStructEnd()
9017 
 
9018 
  def write(self, oprot):
9019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9021 
      return
9022 
    oprot.writeStructBegin('addBadInventory_args')
9023 
    if self.itemId is not None:
9024 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
9025 
      oprot.writeI64(self.itemId)
9026 
      oprot.writeFieldEnd()
9027 
    if self.warehouseId is not None:
9028 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9029 
      oprot.writeI64(self.warehouseId)
9030 
      oprot.writeFieldEnd()
9031 
    if self.quantity is not None:
9032 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
9033 
      oprot.writeI64(self.quantity)
9034 
      oprot.writeFieldEnd()
9035 
    oprot.writeFieldStop()
9036 
    oprot.writeStructEnd()
9037 
 
9038 
  def validate(self):
9039 
    return
9040 
 
9041 
 
9042 
  def __repr__(self):
9043 
    L = ['%s=%r' % (key, value)
9044 
      for key, value in self.__dict__.iteritems()]
9045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9046 
 
9047 
  def __eq__(self, other):
9048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9049 
 
9050 
  def __ne__(self, other):
9051 
    return not (self == other)
9052 
 
9053 
class addBadInventory_result:
9054 
  """
9055 
  Attributes:
9056 
   - cex
9057 
  """
9058 
 
9059 
  thrift_spec = (
9060 
    None, # 0
9061 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
9062 
  )
9063 
 
9064 
  def __init__(self, cex=None,):
9065 
    self.cex = cex
9066 
 
9067 
  def read(self, iprot):
9068 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9069 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9070 
      return
9071 
    iprot.readStructBegin()
9072 
    while True:
9073 
      (fname, ftype, fid) = iprot.readFieldBegin()
9074 
      if ftype == TType.STOP:
9075 
        break
9076 
      if fid == 1:
9077 
        if ftype == TType.STRUCT:
9078 
          self.cex = InventoryServiceException()
9079 
          self.cex.read(iprot)
9080 
        else:
9081 
          iprot.skip(ftype)
9082 
      else:
9083 
        iprot.skip(ftype)
9084 
      iprot.readFieldEnd()
9085 
    iprot.readStructEnd()
9086 
 
9087 
  def write(self, oprot):
9088 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9089 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9090 
      return
9091 
    oprot.writeStructBegin('addBadInventory_result')
9092 
    if self.cex is not None:
9093 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9094 
      self.cex.write(oprot)
9095 
      oprot.writeFieldEnd()
9096 
    oprot.writeFieldStop()
9097 
    oprot.writeStructEnd()
9098 
 
9099 
  def validate(self):
9100 
    return
9101 
 
9102 
 
9103 
  def __repr__(self):
9104 
    L = ['%s=%r' % (key, value)
9105 
      for key, value in self.__dict__.iteritems()]
9106 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9107 
 
9108 
  def __eq__(self, other):
9109 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9110 
 
9111 
  def __ne__(self, other):
9112 
    return not (self == other)
9113 
 
9114 
class getShippingLocations_args:
9115 
 
9116 
  thrift_spec = (
9117 
  )
9118 
 
9119 
  def read(self, iprot):
9120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9122 
      return
9123 
    iprot.readStructBegin()
9124 
    while True:
9125 
      (fname, ftype, fid) = iprot.readFieldBegin()
9126 
      if ftype == TType.STOP:
9127 
        break
9128 
      else:
9129 
        iprot.skip(ftype)
9130 
      iprot.readFieldEnd()
9131 
    iprot.readStructEnd()
9132 
 
9133 
  def write(self, oprot):
9134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9136 
      return
9137 
    oprot.writeStructBegin('getShippingLocations_args')
9138 
    oprot.writeFieldStop()
9139 
    oprot.writeStructEnd()
9140 
 
9141 
  def validate(self):
9142 
    return
9143 
 
9144 
 
9145 
  def __repr__(self):
9146 
    L = ['%s=%r' % (key, value)
9147 
      for key, value in self.__dict__.iteritems()]
9148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9149 
 
9150 
  def __eq__(self, other):
9151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9152 
 
9153 
  def __ne__(self, other):
9154 
    return not (self == other)
9155 
 
9156 
class getShippingLocations_result:
9157 
  """
9158 
  Attributes:
9159 
   - success
9160 
  """
9161 
 
9162 
  thrift_spec = (
9163 
    (0, TType.LIST, 'success', (TType.STRUCT,(Warehouse, Warehouse.thrift_spec)), None, ), # 0
9164 
  )
9165 
 
9166 
  def __init__(self, success=None,):
9167 
    self.success = success
9168 
 
9169 
  def read(self, iprot):
9170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9172 
      return
9173 
    iprot.readStructBegin()
9174 
    while True:
9175 
      (fname, ftype, fid) = iprot.readFieldBegin()
9176 
      if ftype == TType.STOP:
9177 
        break
9178 
      if fid == 0:
9179 
        if ftype == TType.LIST:
9180 
          self.success = []
8182 amar.kumar 9181 
          (_etype129, _size126) = iprot.readListBegin()
9182 
          for _i130 in xrange(_size126):
9183 
            _elem131 = Warehouse()
9184 
            _elem131.read(iprot)
9185 
            self.success.append(_elem131)
5944 mandeep.dh 9186 
          iprot.readListEnd()
9187 
        else:
9188 
          iprot.skip(ftype)
9189 
      else:
9190 
        iprot.skip(ftype)
9191 
      iprot.readFieldEnd()
9192 
    iprot.readStructEnd()
9193 
 
9194 
  def write(self, oprot):
9195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9197 
      return
9198 
    oprot.writeStructBegin('getShippingLocations_result')
9199 
    if self.success is not None:
9200 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9201 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 9202 
      for iter132 in self.success:
9203 
        iter132.write(oprot)
5944 mandeep.dh 9204 
      oprot.writeListEnd()
9205 
      oprot.writeFieldEnd()
9206 
    oprot.writeFieldStop()
9207 
    oprot.writeStructEnd()
9208 
 
9209 
  def validate(self):
9210 
    return
9211 
 
9212 
 
9213 
  def __repr__(self):
9214 
    L = ['%s=%r' % (key, value)
9215 
      for key, value in self.__dict__.iteritems()]
9216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9217 
 
9218 
  def __eq__(self, other):
9219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9220 
 
9221 
  def __ne__(self, other):
9222 
    return not (self == other)
9223 
 
9224 
class getAllVendorItemMappings_args:
9225 
 
9226 
  thrift_spec = (
9227 
  )
9228 
 
9229 
  def read(self, iprot):
9230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9232 
      return
9233 
    iprot.readStructBegin()
9234 
    while True:
9235 
      (fname, ftype, fid) = iprot.readFieldBegin()
9236 
      if ftype == TType.STOP:
9237 
        break
9238 
      else:
9239 
        iprot.skip(ftype)
9240 
      iprot.readFieldEnd()
9241 
    iprot.readStructEnd()
9242 
 
9243 
  def write(self, oprot):
9244 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9245 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9246 
      return
9247 
    oprot.writeStructBegin('getAllVendorItemMappings_args')
9248 
    oprot.writeFieldStop()
9249 
    oprot.writeStructEnd()
9250 
 
9251 
  def validate(self):
9252 
    return
9253 
 
9254 
 
9255 
  def __repr__(self):
9256 
    L = ['%s=%r' % (key, value)
9257 
      for key, value in self.__dict__.iteritems()]
9258 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9259 
 
9260 
  def __eq__(self, other):
9261 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9262 
 
9263 
  def __ne__(self, other):
9264 
    return not (self == other)
9265 
 
9266 
class getAllVendorItemMappings_result:
9267 
  """
9268 
  Attributes:
9269 
   - success
9270 
  """
9271 
 
9272 
  thrift_spec = (
9273 
    (0, TType.LIST, 'success', (TType.STRUCT,(VendorItemMapping, VendorItemMapping.thrift_spec)), None, ), # 0
9274 
  )
9275 
 
9276 
  def __init__(self, success=None,):
9277 
    self.success = success
9278 
 
9279 
  def read(self, iprot):
9280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9282 
      return
9283 
    iprot.readStructBegin()
9284 
    while True:
9285 
      (fname, ftype, fid) = iprot.readFieldBegin()
9286 
      if ftype == TType.STOP:
9287 
        break
9288 
      if fid == 0:
9289 
        if ftype == TType.LIST:
9290 
          self.success = []
8182 amar.kumar 9291 
          (_etype136, _size133) = iprot.readListBegin()
9292 
          for _i137 in xrange(_size133):
9293 
            _elem138 = VendorItemMapping()
9294 
            _elem138.read(iprot)
9295 
            self.success.append(_elem138)
5944 mandeep.dh 9296 
          iprot.readListEnd()
9297 
        else:
9298 
          iprot.skip(ftype)
9299 
      else:
9300 
        iprot.skip(ftype)
9301 
      iprot.readFieldEnd()
9302 
    iprot.readStructEnd()
9303 
 
9304 
  def write(self, oprot):
9305 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9306 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9307 
      return
9308 
    oprot.writeStructBegin('getAllVendorItemMappings_result')
9309 
    if self.success is not None:
9310 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9311 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 9312 
      for iter139 in self.success:
9313 
        iter139.write(oprot)
5944 mandeep.dh 9314 
      oprot.writeListEnd()
9315 
      oprot.writeFieldEnd()
9316 
    oprot.writeFieldStop()
9317 
    oprot.writeStructEnd()
9318 
 
9319 
  def validate(self):
9320 
    return
9321 
 
9322 
 
9323 
  def __repr__(self):
9324 
    L = ['%s=%r' % (key, value)
9325 
      for key, value in self.__dict__.iteritems()]
9326 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9327 
 
9328 
  def __eq__(self, other):
9329 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9330 
 
9331 
  def __ne__(self, other):
9332 
    return not (self == other)
9333 
 
9334 
class getInventorySnapshot_args:
9335 
  """
9336 
  Attributes:
9337 
   - warehouseId
9338 
  """
9339 
 
9340 
  thrift_spec = (
9341 
    None, # 0
9342 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9343 
  )
9344 
 
9345 
  def __init__(self, warehouseId=None,):
9346 
    self.warehouseId = warehouseId
9347 
 
9348 
  def read(self, iprot):
9349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9351 
      return
9352 
    iprot.readStructBegin()
9353 
    while True:
9354 
      (fname, ftype, fid) = iprot.readFieldBegin()
9355 
      if ftype == TType.STOP:
9356 
        break
9357 
      if fid == 1:
9358 
        if ftype == TType.I64:
9359 
          self.warehouseId = iprot.readI64();
9360 
        else:
9361 
          iprot.skip(ftype)
9362 
      else:
9363 
        iprot.skip(ftype)
9364 
      iprot.readFieldEnd()
9365 
    iprot.readStructEnd()
9366 
 
9367 
  def write(self, oprot):
9368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9370 
      return
9371 
    oprot.writeStructBegin('getInventorySnapshot_args')
9372 
    if self.warehouseId is not None:
9373 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9374 
      oprot.writeI64(self.warehouseId)
9375 
      oprot.writeFieldEnd()
9376 
    oprot.writeFieldStop()
9377 
    oprot.writeStructEnd()
9378 
 
9379 
  def validate(self):
9380 
    return
9381 
 
9382 
 
9383 
  def __repr__(self):
9384 
    L = ['%s=%r' % (key, value)
9385 
      for key, value in self.__dict__.iteritems()]
9386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9387 
 
9388 
  def __eq__(self, other):
9389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9390 
 
9391 
  def __ne__(self, other):
9392 
    return not (self == other)
9393 
 
9394 
class getInventorySnapshot_result:
9395 
  """
9396 
  Attributes:
9397 
   - success
9398 
  """
9399 
 
9400 
  thrift_spec = (
9401 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRUCT,(ItemInventory, ItemInventory.thrift_spec)), None, ), # 0
9402 
  )
9403 
 
9404 
  def __init__(self, success=None,):
9405 
    self.success = success
9406 
 
9407 
  def read(self, iprot):
9408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9410 
      return
9411 
    iprot.readStructBegin()
9412 
    while True:
9413 
      (fname, ftype, fid) = iprot.readFieldBegin()
9414 
      if ftype == TType.STOP:
9415 
        break
9416 
      if fid == 0:
9417 
        if ftype == TType.MAP:
9418 
          self.success = {}
8182 amar.kumar 9419 
          (_ktype141, _vtype142, _size140 ) = iprot.readMapBegin()
9420 
          for _i144 in xrange(_size140):
9421 
            _key145 = iprot.readI64();
9422 
            _val146 = ItemInventory()
9423 
            _val146.read(iprot)
9424 
            self.success[_key145] = _val146
5944 mandeep.dh 9425 
          iprot.readMapEnd()
9426 
        else:
9427 
          iprot.skip(ftype)
9428 
      else:
9429 
        iprot.skip(ftype)
9430 
      iprot.readFieldEnd()
9431 
    iprot.readStructEnd()
9432 
 
9433 
  def write(self, oprot):
9434 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9435 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9436 
      return
9437 
    oprot.writeStructBegin('getInventorySnapshot_result')
9438 
    if self.success is not None:
9439 
      oprot.writeFieldBegin('success', TType.MAP, 0)
9440 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.success))
8182 amar.kumar 9441 
      for kiter147,viter148 in self.success.items():
9442 
        oprot.writeI64(kiter147)
9443 
        viter148.write(oprot)
5944 mandeep.dh 9444 
      oprot.writeMapEnd()
9445 
      oprot.writeFieldEnd()
9446 
    oprot.writeFieldStop()
9447 
    oprot.writeStructEnd()
9448 
 
9449 
  def validate(self):
9450 
    return
9451 
 
9452 
 
9453 
  def __repr__(self):
9454 
    L = ['%s=%r' % (key, value)
9455 
      for key, value in self.__dict__.iteritems()]
9456 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9457 
 
9458 
  def __eq__(self, other):
9459 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9460 
 
9461 
  def __ne__(self, other):
9462 
    return not (self == other)
9463 
 
9464 
class clearItemAvailabilityCache_args:
9465 
 
9466 
  thrift_spec = (
9467 
  )
9468 
 
9469 
  def read(self, iprot):
9470 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9471 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9472 
      return
9473 
    iprot.readStructBegin()
9474 
    while True:
9475 
      (fname, ftype, fid) = iprot.readFieldBegin()
9476 
      if ftype == TType.STOP:
9477 
        break
9478 
      else:
9479 
        iprot.skip(ftype)
9480 
      iprot.readFieldEnd()
9481 
    iprot.readStructEnd()
9482 
 
9483 
  def write(self, oprot):
9484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9486 
      return
9487 
    oprot.writeStructBegin('clearItemAvailabilityCache_args')
9488 
    oprot.writeFieldStop()
9489 
    oprot.writeStructEnd()
9490 
 
9491 
  def validate(self):
9492 
    return
9493 
 
9494 
 
9495 
  def __repr__(self):
9496 
    L = ['%s=%r' % (key, value)
9497 
      for key, value in self.__dict__.iteritems()]
9498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9499 
 
9500 
  def __eq__(self, other):
9501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9502 
 
9503 
  def __ne__(self, other):
9504 
    return not (self == other)
9505 
 
9506 
class clearItemAvailabilityCache_result:
9507 
 
9508 
  thrift_spec = (
9509 
  )
9510 
 
9511 
  def read(self, iprot):
9512 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9513 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9514 
      return
9515 
    iprot.readStructBegin()
9516 
    while True:
9517 
      (fname, ftype, fid) = iprot.readFieldBegin()
9518 
      if ftype == TType.STOP:
9519 
        break
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('clearItemAvailabilityCache_result')
9530 
    oprot.writeFieldStop()
9531 
    oprot.writeStructEnd()
9532 
 
9533 
  def validate(self):
9534 
    return
9535 
 
9536 
 
9537 
  def __repr__(self):
9538 
    L = ['%s=%r' % (key, value)
9539 
      for key, value in self.__dict__.iteritems()]
9540 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9541 
 
9542 
  def __eq__(self, other):
9543 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9544 
 
9545 
  def __ne__(self, other):
9546 
    return not (self == other)
9547 
 
9548 
class updateVendorString_args:
9549 
  """
9550 
  Attributes:
9551 
   - warehouseId
9552 
   - vendorString
9553 
  """
9554 
 
9555 
  thrift_spec = (
9556 
    None, # 0
9557 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9558 
    (2, TType.STRING, 'vendorString', None, None, ), # 2
9559 
  )
9560 
 
9561 
  def __init__(self, warehouseId=None, vendorString=None,):
9562 
    self.warehouseId = warehouseId
9563 
    self.vendorString = vendorString
9564 
 
9565 
  def read(self, iprot):
9566 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9567 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9568 
      return
9569 
    iprot.readStructBegin()
9570 
    while True:
9571 
      (fname, ftype, fid) = iprot.readFieldBegin()
9572 
      if ftype == TType.STOP:
9573 
        break
9574 
      if fid == 1:
9575 
        if ftype == TType.I64:
9576 
          self.warehouseId = iprot.readI64();
9577 
        else:
9578 
          iprot.skip(ftype)
9579 
      elif fid == 2:
9580 
        if ftype == TType.STRING:
9581 
          self.vendorString = iprot.readString();
9582 
        else:
9583 
          iprot.skip(ftype)
9584 
      else:
9585 
        iprot.skip(ftype)
9586 
      iprot.readFieldEnd()
9587 
    iprot.readStructEnd()
9588 
 
9589 
  def write(self, oprot):
9590 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9591 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9592 
      return
9593 
    oprot.writeStructBegin('updateVendorString_args')
9594 
    if self.warehouseId is not None:
9595 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9596 
      oprot.writeI64(self.warehouseId)
9597 
      oprot.writeFieldEnd()
9598 
    if self.vendorString is not None:
9599 
      oprot.writeFieldBegin('vendorString', TType.STRING, 2)
9600 
      oprot.writeString(self.vendorString)
9601 
      oprot.writeFieldEnd()
9602 
    oprot.writeFieldStop()
9603 
    oprot.writeStructEnd()
9604 
 
9605 
  def validate(self):
9606 
    return
9607 
 
9608 
 
9609 
  def __repr__(self):
9610 
    L = ['%s=%r' % (key, value)
9611 
      for key, value in self.__dict__.iteritems()]
9612 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9613 
 
9614 
  def __eq__(self, other):
9615 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9616 
 
9617 
  def __ne__(self, other):
9618 
    return not (self == other)
9619 
 
9620 
class updateVendorString_result:
9621 
 
9622 
  thrift_spec = (
9623 
  )
9624 
 
9625 
  def read(self, iprot):
9626 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9627 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9628 
      return
9629 
    iprot.readStructBegin()
9630 
    while True:
9631 
      (fname, ftype, fid) = iprot.readFieldBegin()
9632 
      if ftype == TType.STOP:
9633 
        break
9634 
      else:
9635 
        iprot.skip(ftype)
9636 
      iprot.readFieldEnd()
9637 
    iprot.readStructEnd()
9638 
 
9639 
  def write(self, oprot):
9640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9642 
      return
9643 
    oprot.writeStructBegin('updateVendorString_result')
9644 
    oprot.writeFieldStop()
9645 
    oprot.writeStructEnd()
9646 
 
9647 
  def validate(self):
9648 
    return
9649 
 
9650 
 
9651 
  def __repr__(self):
9652 
    L = ['%s=%r' % (key, value)
9653 
      for key, value in self.__dict__.iteritems()]
9654 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9655 
 
9656 
  def __eq__(self, other):
9657 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9658 
 
9659 
  def __ne__(self, other):
9660 
    return not (self == other)
6096 amit.gupta 9661 
 
9662 
class clearItemAvailabilityCacheForItem_args:
9663 
  """
9664 
  Attributes:
9665 
   - item_id
9666 
  """
9667 
 
9668 
  thrift_spec = (
9669 
    None, # 0
9670 
    (1, TType.I64, 'item_id', None, None, ), # 1
9671 
  )
9672 
 
9673 
  def __init__(self, item_id=None,):
9674 
    self.item_id = item_id
9675 
 
9676 
  def read(self, iprot):
9677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9679 
      return
9680 
    iprot.readStructBegin()
9681 
    while True:
9682 
      (fname, ftype, fid) = iprot.readFieldBegin()
9683 
      if ftype == TType.STOP:
9684 
        break
9685 
      if fid == 1:
9686 
        if ftype == TType.I64:
9687 
          self.item_id = iprot.readI64();
9688 
        else:
9689 
          iprot.skip(ftype)
9690 
      else:
9691 
        iprot.skip(ftype)
9692 
      iprot.readFieldEnd()
9693 
    iprot.readStructEnd()
9694 
 
9695 
  def write(self, oprot):
9696 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9697 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9698 
      return
9699 
    oprot.writeStructBegin('clearItemAvailabilityCacheForItem_args')
9700 
    if self.item_id is not None:
9701 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
9702 
      oprot.writeI64(self.item_id)
9703 
      oprot.writeFieldEnd()
9704 
    oprot.writeFieldStop()
9705 
    oprot.writeStructEnd()
9706 
 
9707 
  def validate(self):
9708 
    return
9709 
 
9710 
 
9711 
  def __repr__(self):
9712 
    L = ['%s=%r' % (key, value)
9713 
      for key, value in self.__dict__.iteritems()]
9714 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9715 
 
9716 
  def __eq__(self, other):
9717 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9718 
 
9719 
  def __ne__(self, other):
9720 
    return not (self == other)
9721 
 
9722 
class clearItemAvailabilityCacheForItem_result:
9723 
 
9724 
  thrift_spec = (
9725 
  )
9726 
 
9727 
  def read(self, iprot):
9728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9730 
      return
9731 
    iprot.readStructBegin()
9732 
    while True:
9733 
      (fname, ftype, fid) = iprot.readFieldBegin()
9734 
      if ftype == TType.STOP:
9735 
        break
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('clearItemAvailabilityCacheForItem_result')
9746 
    oprot.writeFieldStop()
9747 
    oprot.writeStructEnd()
9748 
 
9749 
  def validate(self):
9750 
    return
9751 
 
9752 
 
9753 
  def __repr__(self):
9754 
    L = ['%s=%r' % (key, value)
9755 
      for key, value in self.__dict__.iteritems()]
9756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9757 
 
9758 
  def __eq__(self, other):
9759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9760 
 
9761 
  def __ne__(self, other):
9762 
    return not (self == other)
6467 amar.kumar 9763 
 
9764 
class getOurWarehouseIdForVendor_args:
9765 
  """
9766 
  Attributes:
9767 
   - vendorId
7718 amar.kumar 9768 
   - billingWarehouseId
6467 amar.kumar 9769 
  """
9770 
 
9771 
  thrift_spec = (
9772 
    None, # 0
9773 
    (1, TType.I64, 'vendorId', None, None, ), # 1
7718 amar.kumar 9774 
    (2, TType.I64, 'billingWarehouseId', None, None, ), # 2
6467 amar.kumar 9775 
  )
9776 
 
7718 amar.kumar 9777 
  def __init__(self, vendorId=None, billingWarehouseId=None,):
6467 amar.kumar 9778 
    self.vendorId = vendorId
7718 amar.kumar 9779 
    self.billingWarehouseId = billingWarehouseId
6467 amar.kumar 9780 
 
9781 
  def read(self, iprot):
9782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9784 
      return
9785 
    iprot.readStructBegin()
9786 
    while True:
9787 
      (fname, ftype, fid) = iprot.readFieldBegin()
9788 
      if ftype == TType.STOP:
9789 
        break
9790 
      if fid == 1:
9791 
        if ftype == TType.I64:
9792 
          self.vendorId = iprot.readI64();
9793 
        else:
9794 
          iprot.skip(ftype)
7718 amar.kumar 9795 
      elif fid == 2:
9796 
        if ftype == TType.I64:
9797 
          self.billingWarehouseId = iprot.readI64();
9798 
        else:
9799 
          iprot.skip(ftype)
6467 amar.kumar 9800 
      else:
9801 
        iprot.skip(ftype)
9802 
      iprot.readFieldEnd()
9803 
    iprot.readStructEnd()
9804 
 
9805 
  def write(self, oprot):
9806 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9807 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9808 
      return
9809 
    oprot.writeStructBegin('getOurWarehouseIdForVendor_args')
9810 
    if self.vendorId is not None:
9811 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
9812 
      oprot.writeI64(self.vendorId)
9813 
      oprot.writeFieldEnd()
7718 amar.kumar 9814 
    if self.billingWarehouseId is not None:
9815 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 2)
9816 
      oprot.writeI64(self.billingWarehouseId)
9817 
      oprot.writeFieldEnd()
6467 amar.kumar 9818 
    oprot.writeFieldStop()
9819 
    oprot.writeStructEnd()
9820 
 
9821 
  def validate(self):
9822 
    return
9823 
 
9824 
 
9825 
  def __repr__(self):
9826 
    L = ['%s=%r' % (key, value)
9827 
      for key, value in self.__dict__.iteritems()]
9828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9829 
 
9830 
  def __eq__(self, other):
9831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9832 
 
9833 
  def __ne__(self, other):
9834 
    return not (self == other)
9835 
 
9836 
class getOurWarehouseIdForVendor_result:
9837 
  """
9838 
  Attributes:
9839 
   - success
9840 
  """
9841 
 
9842 
  thrift_spec = (
9843 
    (0, TType.I64, 'success', None, None, ), # 0
9844 
  )
9845 
 
9846 
  def __init__(self, success=None,):
9847 
    self.success = success
9848 
 
9849 
  def read(self, iprot):
9850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9852 
      return
9853 
    iprot.readStructBegin()
9854 
    while True:
9855 
      (fname, ftype, fid) = iprot.readFieldBegin()
9856 
      if ftype == TType.STOP:
9857 
        break
9858 
      if fid == 0:
9859 
        if ftype == TType.I64:
9860 
          self.success = iprot.readI64();
9861 
        else:
9862 
          iprot.skip(ftype)
9863 
      else:
9864 
        iprot.skip(ftype)
9865 
      iprot.readFieldEnd()
9866 
    iprot.readStructEnd()
9867 
 
9868 
  def write(self, oprot):
9869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9871 
      return
9872 
    oprot.writeStructBegin('getOurWarehouseIdForVendor_result')
9873 
    if self.success is not None:
9874 
      oprot.writeFieldBegin('success', TType.I64, 0)
9875 
      oprot.writeI64(self.success)
9876 
      oprot.writeFieldEnd()
9877 
    oprot.writeFieldStop()
9878 
    oprot.writeStructEnd()
9879 
 
9880 
  def validate(self):
9881 
    return
9882 
 
9883 
 
9884 
  def __repr__(self):
9885 
    L = ['%s=%r' % (key, value)
9886 
      for key, value in self.__dict__.iteritems()]
9887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9888 
 
9889 
  def __eq__(self, other):
9890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9891 
 
9892 
  def __ne__(self, other):
9893 
    return not (self == other)
6484 amar.kumar 9894 
 
9895 
class getItemAvailabilitiesAtOurWarehouses_args:
9896 
  """
9897 
  Attributes:
9898 
   - item_ids
9899 
  """
9900 
 
9901 
  thrift_spec = (
9902 
    None, # 0
9903 
    (1, TType.LIST, 'item_ids', (TType.I64,None), None, ), # 1
9904 
  )
9905 
 
9906 
  def __init__(self, item_ids=None,):
9907 
    self.item_ids = item_ids
9908 
 
9909 
  def read(self, iprot):
9910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9912 
      return
9913 
    iprot.readStructBegin()
9914 
    while True:
9915 
      (fname, ftype, fid) = iprot.readFieldBegin()
9916 
      if ftype == TType.STOP:
9917 
        break
9918 
      if fid == 1:
9919 
        if ftype == TType.LIST:
9920 
          self.item_ids = []
8182 amar.kumar 9921 
          (_etype152, _size149) = iprot.readListBegin()
9922 
          for _i153 in xrange(_size149):
9923 
            _elem154 = iprot.readI64();
9924 
            self.item_ids.append(_elem154)
6484 amar.kumar 9925 
          iprot.readListEnd()
9926 
        else:
9927 
          iprot.skip(ftype)
9928 
      else:
9929 
        iprot.skip(ftype)
9930 
      iprot.readFieldEnd()
9931 
    iprot.readStructEnd()
9932 
 
9933 
  def write(self, oprot):
9934 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9935 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9936 
      return
9937 
    oprot.writeStructBegin('getItemAvailabilitiesAtOurWarehouses_args')
9938 
    if self.item_ids is not None:
9939 
      oprot.writeFieldBegin('item_ids', TType.LIST, 1)
9940 
      oprot.writeListBegin(TType.I64, len(self.item_ids))
8182 amar.kumar 9941 
      for iter155 in self.item_ids:
9942 
        oprot.writeI64(iter155)
6484 amar.kumar 9943 
      oprot.writeListEnd()
9944 
      oprot.writeFieldEnd()
9945 
    oprot.writeFieldStop()
9946 
    oprot.writeStructEnd()
9947 
 
9948 
  def validate(self):
9949 
    return
9950 
 
9951 
 
9952 
  def __repr__(self):
9953 
    L = ['%s=%r' % (key, value)
9954 
      for key, value in self.__dict__.iteritems()]
9955 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9956 
 
9957 
  def __eq__(self, other):
9958 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9959 
 
9960 
  def __ne__(self, other):
9961 
    return not (self == other)
9962 
 
9963 
class getItemAvailabilitiesAtOurWarehouses_result:
9964 
  """
9965 
  Attributes:
9966 
   - success
9967 
  """
9968 
 
9969 
  thrift_spec = (
9970 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
9971 
  )
9972 
 
9973 
  def __init__(self, success=None,):
9974 
    self.success = success
9975 
 
9976 
  def read(self, iprot):
9977 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9978 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9979 
      return
9980 
    iprot.readStructBegin()
9981 
    while True:
9982 
      (fname, ftype, fid) = iprot.readFieldBegin()
9983 
      if ftype == TType.STOP:
9984 
        break
9985 
      if fid == 0:
9986 
        if ftype == TType.MAP:
9987 
          self.success = {}
8182 amar.kumar 9988 
          (_ktype157, _vtype158, _size156 ) = iprot.readMapBegin()
9989 
          for _i160 in xrange(_size156):
9990 
            _key161 = iprot.readI64();
9991 
            _val162 = iprot.readI64();
9992 
            self.success[_key161] = _val162
6484 amar.kumar 9993 
          iprot.readMapEnd()
9994 
        else:
9995 
          iprot.skip(ftype)
9996 
      else:
9997 
        iprot.skip(ftype)
9998 
      iprot.readFieldEnd()
9999 
    iprot.readStructEnd()
10000 
 
10001 
  def write(self, oprot):
10002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10004 
      return
10005 
    oprot.writeStructBegin('getItemAvailabilitiesAtOurWarehouses_result')
10006 
    if self.success is not None:
10007 
      oprot.writeFieldBegin('success', TType.MAP, 0)
10008 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
8182 amar.kumar 10009 
      for kiter163,viter164 in self.success.items():
10010 
        oprot.writeI64(kiter163)
10011 
        oprot.writeI64(viter164)
6484 amar.kumar 10012 
      oprot.writeMapEnd()
10013 
      oprot.writeFieldEnd()
10014 
    oprot.writeFieldStop()
10015 
    oprot.writeStructEnd()
10016 
 
10017 
  def validate(self):
10018 
    return
10019 
 
10020 
 
10021 
  def __repr__(self):
10022 
    L = ['%s=%r' % (key, value)
10023 
      for key, value in self.__dict__.iteritems()]
10024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10025 
 
10026 
  def __eq__(self, other):
10027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10028 
 
10029 
  def __ne__(self, other):
10030 
    return not (self == other)
6531 vikram.rag 10031 
 
10032 
class getMonitoredWarehouseForVendors_args:
10033 
  """
10034 
  Attributes:
10035 
   - vendorIds
10036 
  """
10037 
 
10038 
  thrift_spec = (
10039 
    None, # 0
10040 
    (1, TType.LIST, 'vendorIds', (TType.I64,None), None, ), # 1
10041 
  )
10042 
 
10043 
  def __init__(self, vendorIds=None,):
10044 
    self.vendorIds = vendorIds
10045 
 
10046 
  def read(self, iprot):
10047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10049 
      return
10050 
    iprot.readStructBegin()
10051 
    while True:
10052 
      (fname, ftype, fid) = iprot.readFieldBegin()
10053 
      if ftype == TType.STOP:
10054 
        break
10055 
      if fid == 1:
10056 
        if ftype == TType.LIST:
10057 
          self.vendorIds = []
8182 amar.kumar 10058 
          (_etype168, _size165) = iprot.readListBegin()
10059 
          for _i169 in xrange(_size165):
10060 
            _elem170 = iprot.readI64();
10061 
            self.vendorIds.append(_elem170)
6531 vikram.rag 10062 
          iprot.readListEnd()
10063 
        else:
10064 
          iprot.skip(ftype)
10065 
      else:
10066 
        iprot.skip(ftype)
10067 
      iprot.readFieldEnd()
10068 
    iprot.readStructEnd()
10069 
 
10070 
  def write(self, oprot):
10071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10073 
      return
10074 
    oprot.writeStructBegin('getMonitoredWarehouseForVendors_args')
10075 
    if self.vendorIds is not None:
10076 
      oprot.writeFieldBegin('vendorIds', TType.LIST, 1)
10077 
      oprot.writeListBegin(TType.I64, len(self.vendorIds))
8182 amar.kumar 10078 
      for iter171 in self.vendorIds:
10079 
        oprot.writeI64(iter171)
6531 vikram.rag 10080 
      oprot.writeListEnd()
10081 
      oprot.writeFieldEnd()
10082 
    oprot.writeFieldStop()
10083 
    oprot.writeStructEnd()
10084 
 
10085 
  def validate(self):
10086 
    return
10087 
 
10088 
 
10089 
  def __repr__(self):
10090 
    L = ['%s=%r' % (key, value)
10091 
      for key, value in self.__dict__.iteritems()]
10092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10093 
 
10094 
  def __eq__(self, other):
10095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10096 
 
10097 
  def __ne__(self, other):
10098 
    return not (self == other)
10099 
 
10100 
class getMonitoredWarehouseForVendors_result:
10101 
  """
10102 
  Attributes:
10103 
   - success
10104 
  """
10105 
 
10106 
  thrift_spec = (
10107 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10108 
  )
10109 
 
10110 
  def __init__(self, success=None,):
10111 
    self.success = success
10112 
 
10113 
  def read(self, iprot):
10114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10116 
      return
10117 
    iprot.readStructBegin()
10118 
    while True:
10119 
      (fname, ftype, fid) = iprot.readFieldBegin()
10120 
      if ftype == TType.STOP:
10121 
        break
10122 
      if fid == 0:
10123 
        if ftype == TType.LIST:
10124 
          self.success = []
8182 amar.kumar 10125 
          (_etype175, _size172) = iprot.readListBegin()
10126 
          for _i176 in xrange(_size172):
10127 
            _elem177 = iprot.readI64();
10128 
            self.success.append(_elem177)
6531 vikram.rag 10129 
          iprot.readListEnd()
10130 
        else:
10131 
          iprot.skip(ftype)
10132 
      else:
10133 
        iprot.skip(ftype)
10134 
      iprot.readFieldEnd()
10135 
    iprot.readStructEnd()
10136 
 
10137 
  def write(self, oprot):
10138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10140 
      return
10141 
    oprot.writeStructBegin('getMonitoredWarehouseForVendors_result')
10142 
    if self.success is not None:
10143 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10144 
      oprot.writeListBegin(TType.I64, len(self.success))
8182 amar.kumar 10145 
      for iter178 in self.success:
10146 
        oprot.writeI64(iter178)
6531 vikram.rag 10147 
      oprot.writeListEnd()
10148 
      oprot.writeFieldEnd()
10149 
    oprot.writeFieldStop()
10150 
    oprot.writeStructEnd()
10151 
 
10152 
  def validate(self):
10153 
    return
10154 
 
10155 
 
10156 
  def __repr__(self):
10157 
    L = ['%s=%r' % (key, value)
10158 
      for key, value in self.__dict__.iteritems()]
10159 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10160 
 
10161 
  def __eq__(self, other):
10162 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10163 
 
10164 
  def __ne__(self, other):
10165 
    return not (self == other)
10166 
 
10167 
class getIgnoredWarehouseidsAndItemids_args:
10168 
 
10169 
  thrift_spec = (
10170 
  )
10171 
 
10172 
  def read(self, iprot):
10173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10175 
      return
10176 
    iprot.readStructBegin()
10177 
    while True:
10178 
      (fname, ftype, fid) = iprot.readFieldBegin()
10179 
      if ftype == TType.STOP:
10180 
        break
10181 
      else:
10182 
        iprot.skip(ftype)
10183 
      iprot.readFieldEnd()
10184 
    iprot.readStructEnd()
10185 
 
10186 
  def write(self, oprot):
10187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10189 
      return
10190 
    oprot.writeStructBegin('getIgnoredWarehouseidsAndItemids_args')
10191 
    oprot.writeFieldStop()
10192 
    oprot.writeStructEnd()
10193 
 
10194 
  def validate(self):
10195 
    return
10196 
 
10197 
 
10198 
  def __repr__(self):
10199 
    L = ['%s=%r' % (key, value)
10200 
      for key, value in self.__dict__.iteritems()]
10201 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10202 
 
10203 
  def __eq__(self, other):
10204 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10205 
 
10206 
  def __ne__(self, other):
10207 
    return not (self == other)
10208 
 
10209 
class getIgnoredWarehouseidsAndItemids_result:
10210 
  """
10211 
  Attributes:
10212 
   - success
10213 
  """
10214 
 
10215 
  thrift_spec = (
10216 
    (0, TType.LIST, 'success', (TType.STRUCT,(IgnoredInventoryUpdateItems, IgnoredInventoryUpdateItems.thrift_spec)), None, ), # 0
10217 
  )
10218 
 
10219 
  def __init__(self, success=None,):
10220 
    self.success = success
10221 
 
10222 
  def read(self, iprot):
10223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10225 
      return
10226 
    iprot.readStructBegin()
10227 
    while True:
10228 
      (fname, ftype, fid) = iprot.readFieldBegin()
10229 
      if ftype == TType.STOP:
10230 
        break
10231 
      if fid == 0:
10232 
        if ftype == TType.LIST:
10233 
          self.success = []
8182 amar.kumar 10234 
          (_etype182, _size179) = iprot.readListBegin()
10235 
          for _i183 in xrange(_size179):
10236 
            _elem184 = IgnoredInventoryUpdateItems()
10237 
            _elem184.read(iprot)
10238 
            self.success.append(_elem184)
6531 vikram.rag 10239 
          iprot.readListEnd()
10240 
        else:
10241 
          iprot.skip(ftype)
10242 
      else:
10243 
        iprot.skip(ftype)
10244 
      iprot.readFieldEnd()
10245 
    iprot.readStructEnd()
10246 
 
10247 
  def write(self, oprot):
10248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10250 
      return
10251 
    oprot.writeStructBegin('getIgnoredWarehouseidsAndItemids_result')
10252 
    if self.success is not None:
10253 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10254 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 10255 
      for iter185 in self.success:
10256 
        iter185.write(oprot)
6531 vikram.rag 10257 
      oprot.writeListEnd()
10258 
      oprot.writeFieldEnd()
10259 
    oprot.writeFieldStop()
10260 
    oprot.writeStructEnd()
10261 
 
10262 
  def validate(self):
10263 
    return
10264 
 
10265 
 
10266 
  def __repr__(self):
10267 
    L = ['%s=%r' % (key, value)
10268 
      for key, value in self.__dict__.iteritems()]
10269 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10270 
 
10271 
  def __eq__(self, other):
10272 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10273 
 
10274 
  def __ne__(self, other):
10275 
    return not (self == other)
10276 
 
10277 
class insertItemtoIgnoreInventoryUpdatelist_args:
10278 
  """
10279 
  Attributes:
10280 
   - item_id
10281 
   - warehouse_id
10282 
  """
10283 
 
10284 
  thrift_spec = (
10285 
    None, # 0
10286 
    (1, TType.I64, 'item_id', None, None, ), # 1
10287 
    (2, TType.I64, 'warehouse_id', None, None, ), # 2
10288 
  )
10289 
 
10290 
  def __init__(self, item_id=None, warehouse_id=None,):
10291 
    self.item_id = item_id
10292 
    self.warehouse_id = warehouse_id
10293 
 
10294 
  def read(self, iprot):
10295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10297 
      return
10298 
    iprot.readStructBegin()
10299 
    while True:
10300 
      (fname, ftype, fid) = iprot.readFieldBegin()
10301 
      if ftype == TType.STOP:
10302 
        break
10303 
      if fid == 1:
10304 
        if ftype == TType.I64:
10305 
          self.item_id = iprot.readI64();
10306 
        else:
10307 
          iprot.skip(ftype)
10308 
      elif fid == 2:
10309 
        if ftype == TType.I64:
10310 
          self.warehouse_id = iprot.readI64();
10311 
        else:
10312 
          iprot.skip(ftype)
10313 
      else:
10314 
        iprot.skip(ftype)
10315 
      iprot.readFieldEnd()
10316 
    iprot.readStructEnd()
10317 
 
10318 
  def write(self, oprot):
10319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10321 
      return
10322 
    oprot.writeStructBegin('insertItemtoIgnoreInventoryUpdatelist_args')
10323 
    if self.item_id is not None:
10324 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
10325 
      oprot.writeI64(self.item_id)
10326 
      oprot.writeFieldEnd()
10327 
    if self.warehouse_id is not None:
10328 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 2)
10329 
      oprot.writeI64(self.warehouse_id)
10330 
      oprot.writeFieldEnd()
10331 
    oprot.writeFieldStop()
10332 
    oprot.writeStructEnd()
10333 
 
10334 
  def validate(self):
10335 
    return
10336 
 
10337 
 
10338 
  def __repr__(self):
10339 
    L = ['%s=%r' % (key, value)
10340 
      for key, value in self.__dict__.iteritems()]
10341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10342 
 
10343 
  def __eq__(self, other):
10344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10345 
 
10346 
  def __ne__(self, other):
10347 
    return not (self == other)
10348 
 
10349 
class insertItemtoIgnoreInventoryUpdatelist_result:
10350 
  """
10351 
  Attributes:
10352 
   - success
10353 
  """
10354 
 
10355 
  thrift_spec = (
10356 
    (0, TType.BOOL, 'success', None, None, ), # 0
10357 
  )
10358 
 
10359 
  def __init__(self, success=None,):
10360 
    self.success = success
10361 
 
10362 
  def read(self, iprot):
10363 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10364 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10365 
      return
10366 
    iprot.readStructBegin()
10367 
    while True:
10368 
      (fname, ftype, fid) = iprot.readFieldBegin()
10369 
      if ftype == TType.STOP:
10370 
        break
10371 
      if fid == 0:
10372 
        if ftype == TType.BOOL:
10373 
          self.success = iprot.readBool();
10374 
        else:
10375 
          iprot.skip(ftype)
10376 
      else:
10377 
        iprot.skip(ftype)
10378 
      iprot.readFieldEnd()
10379 
    iprot.readStructEnd()
10380 
 
10381 
  def write(self, oprot):
10382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10384 
      return
10385 
    oprot.writeStructBegin('insertItemtoIgnoreInventoryUpdatelist_result')
10386 
    if self.success is not None:
10387 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10388 
      oprot.writeBool(self.success)
10389 
      oprot.writeFieldEnd()
10390 
    oprot.writeFieldStop()
10391 
    oprot.writeStructEnd()
10392 
 
10393 
  def validate(self):
10394 
    return
10395 
 
10396 
 
10397 
  def __repr__(self):
10398 
    L = ['%s=%r' % (key, value)
10399 
      for key, value in self.__dict__.iteritems()]
10400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10401 
 
10402 
  def __eq__(self, other):
10403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10404 
 
10405 
  def __ne__(self, other):
10406 
    return not (self == other)
10407 
 
10408 
class deleteItemFromIgnoredInventoryUpdateList_args:
10409 
  """
10410 
  Attributes:
10411 
   - item_id
10412 
   - warehouse_id
10413 
  """
10414 
 
10415 
  thrift_spec = (
10416 
    None, # 0
10417 
    (1, TType.I64, 'item_id', None, None, ), # 1
10418 
    (2, TType.I64, 'warehouse_id', None, None, ), # 2
10419 
  )
10420 
 
10421 
  def __init__(self, item_id=None, warehouse_id=None,):
10422 
    self.item_id = item_id
10423 
    self.warehouse_id = warehouse_id
10424 
 
10425 
  def read(self, iprot):
10426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10428 
      return
10429 
    iprot.readStructBegin()
10430 
    while True:
10431 
      (fname, ftype, fid) = iprot.readFieldBegin()
10432 
      if ftype == TType.STOP:
10433 
        break
10434 
      if fid == 1:
10435 
        if ftype == TType.I64:
10436 
          self.item_id = iprot.readI64();
10437 
        else:
10438 
          iprot.skip(ftype)
10439 
      elif fid == 2:
10440 
        if ftype == TType.I64:
10441 
          self.warehouse_id = iprot.readI64();
10442 
        else:
10443 
          iprot.skip(ftype)
10444 
      else:
10445 
        iprot.skip(ftype)
10446 
      iprot.readFieldEnd()
10447 
    iprot.readStructEnd()
10448 
 
10449 
  def write(self, oprot):
10450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10452 
      return
10453 
    oprot.writeStructBegin('deleteItemFromIgnoredInventoryUpdateList_args')
10454 
    if self.item_id is not None:
10455 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
10456 
      oprot.writeI64(self.item_id)
10457 
      oprot.writeFieldEnd()
10458 
    if self.warehouse_id is not None:
10459 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 2)
10460 
      oprot.writeI64(self.warehouse_id)
10461 
      oprot.writeFieldEnd()
10462 
    oprot.writeFieldStop()
10463 
    oprot.writeStructEnd()
10464 
 
10465 
  def validate(self):
10466 
    return
10467 
 
10468 
 
10469 
  def __repr__(self):
10470 
    L = ['%s=%r' % (key, value)
10471 
      for key, value in self.__dict__.iteritems()]
10472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10473 
 
10474 
  def __eq__(self, other):
10475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10476 
 
10477 
  def __ne__(self, other):
10478 
    return not (self == other)
10479 
 
10480 
class deleteItemFromIgnoredInventoryUpdateList_result:
10481 
  """
10482 
  Attributes:
10483 
   - success
10484 
  """
10485 
 
10486 
  thrift_spec = (
10487 
    (0, TType.BOOL, 'success', None, None, ), # 0
10488 
  )
10489 
 
10490 
  def __init__(self, success=None,):
10491 
    self.success = success
10492 
 
10493 
  def read(self, iprot):
10494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10496 
      return
10497 
    iprot.readStructBegin()
10498 
    while True:
10499 
      (fname, ftype, fid) = iprot.readFieldBegin()
10500 
      if ftype == TType.STOP:
10501 
        break
10502 
      if fid == 0:
10503 
        if ftype == TType.BOOL:
10504 
          self.success = iprot.readBool();
10505 
        else:
10506 
          iprot.skip(ftype)
10507 
      else:
10508 
        iprot.skip(ftype)
10509 
      iprot.readFieldEnd()
10510 
    iprot.readStructEnd()
10511 
 
10512 
  def write(self, oprot):
10513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10515 
      return
10516 
    oprot.writeStructBegin('deleteItemFromIgnoredInventoryUpdateList_result')
10517 
    if self.success is not None:
10518 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10519 
      oprot.writeBool(self.success)
10520 
      oprot.writeFieldEnd()
10521 
    oprot.writeFieldStop()
10522 
    oprot.writeStructEnd()
10523 
 
10524 
  def validate(self):
10525 
    return
10526 
 
10527 
 
10528 
  def __repr__(self):
10529 
    L = ['%s=%r' % (key, value)
10530 
      for key, value in self.__dict__.iteritems()]
10531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10532 
 
10533 
  def __eq__(self, other):
10534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10535 
 
10536 
  def __ne__(self, other):
10537 
    return not (self == other)
10538 
 
10539 
class getAllIgnoredInventoryupdateItemsCount_args:
10540 
 
10541 
  thrift_spec = (
10542 
  )
10543 
 
10544 
  def read(self, iprot):
10545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10547 
      return
10548 
    iprot.readStructBegin()
10549 
    while True:
10550 
      (fname, ftype, fid) = iprot.readFieldBegin()
10551 
      if ftype == TType.STOP:
10552 
        break
10553 
      else:
10554 
        iprot.skip(ftype)
10555 
      iprot.readFieldEnd()
10556 
    iprot.readStructEnd()
10557 
 
10558 
  def write(self, oprot):
10559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10561 
      return
10562 
    oprot.writeStructBegin('getAllIgnoredInventoryupdateItemsCount_args')
10563 
    oprot.writeFieldStop()
10564 
    oprot.writeStructEnd()
10565 
 
10566 
  def validate(self):
10567 
    return
10568 
 
10569 
 
10570 
  def __repr__(self):
10571 
    L = ['%s=%r' % (key, value)
10572 
      for key, value in self.__dict__.iteritems()]
10573 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10574 
 
10575 
  def __eq__(self, other):
10576 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10577 
 
10578 
  def __ne__(self, other):
10579 
    return not (self == other)
10580 
 
10581 
class getAllIgnoredInventoryupdateItemsCount_result:
10582 
  """
10583 
  Attributes:
10584 
   - success
10585 
  """
10586 
 
10587 
  thrift_spec = (
10588 
    (0, TType.I32, 'success', None, None, ), # 0
10589 
  )
10590 
 
10591 
  def __init__(self, success=None,):
10592 
    self.success = success
10593 
 
10594 
  def read(self, iprot):
10595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10597 
      return
10598 
    iprot.readStructBegin()
10599 
    while True:
10600 
      (fname, ftype, fid) = iprot.readFieldBegin()
10601 
      if ftype == TType.STOP:
10602 
        break
10603 
      if fid == 0:
10604 
        if ftype == TType.I32:
10605 
          self.success = iprot.readI32();
10606 
        else:
10607 
          iprot.skip(ftype)
10608 
      else:
10609 
        iprot.skip(ftype)
10610 
      iprot.readFieldEnd()
10611 
    iprot.readStructEnd()
10612 
 
10613 
  def write(self, oprot):
10614 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10615 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10616 
      return
10617 
    oprot.writeStructBegin('getAllIgnoredInventoryupdateItemsCount_result')
10618 
    if self.success is not None:
10619 
      oprot.writeFieldBegin('success', TType.I32, 0)
10620 
      oprot.writeI32(self.success)
10621 
      oprot.writeFieldEnd()
10622 
    oprot.writeFieldStop()
10623 
    oprot.writeStructEnd()
10624 
 
10625 
  def validate(self):
10626 
    return
10627 
 
10628 
 
10629 
  def __repr__(self):
10630 
    L = ['%s=%r' % (key, value)
10631 
      for key, value in self.__dict__.iteritems()]
10632 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10633 
 
10634 
  def __eq__(self, other):
10635 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10636 
 
10637 
  def __ne__(self, other):
10638 
    return not (self == other)
10639 
 
10640 
class getIgnoredInventoryUpdateItemids_args:
10641 
  """
10642 
  Attributes:
10643 
   - offset
10644 
   - limit
10645 
  """
10646 
 
10647 
  thrift_spec = (
10648 
    None, # 0
10649 
    (1, TType.I32, 'offset', None, None, ), # 1
10650 
    (2, TType.I32, 'limit', None, None, ), # 2
10651 
  )
10652 
 
10653 
  def __init__(self, offset=None, limit=None,):
10654 
    self.offset = offset
10655 
    self.limit = limit
10656 
 
10657 
  def read(self, iprot):
10658 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10659 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10660 
      return
10661 
    iprot.readStructBegin()
10662 
    while True:
10663 
      (fname, ftype, fid) = iprot.readFieldBegin()
10664 
      if ftype == TType.STOP:
10665 
        break
10666 
      if fid == 1:
10667 
        if ftype == TType.I32:
10668 
          self.offset = iprot.readI32();
10669 
        else:
10670 
          iprot.skip(ftype)
10671 
      elif fid == 2:
10672 
        if ftype == TType.I32:
10673 
          self.limit = iprot.readI32();
10674 
        else:
10675 
          iprot.skip(ftype)
10676 
      else:
10677 
        iprot.skip(ftype)
10678 
      iprot.readFieldEnd()
10679 
    iprot.readStructEnd()
10680 
 
10681 
  def write(self, oprot):
10682 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10683 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10684 
      return
10685 
    oprot.writeStructBegin('getIgnoredInventoryUpdateItemids_args')
10686 
    if self.offset is not None:
10687 
      oprot.writeFieldBegin('offset', TType.I32, 1)
10688 
      oprot.writeI32(self.offset)
10689 
      oprot.writeFieldEnd()
10690 
    if self.limit is not None:
10691 
      oprot.writeFieldBegin('limit', TType.I32, 2)
10692 
      oprot.writeI32(self.limit)
10693 
      oprot.writeFieldEnd()
10694 
    oprot.writeFieldStop()
10695 
    oprot.writeStructEnd()
10696 
 
10697 
  def validate(self):
10698 
    return
10699 
 
10700 
 
10701 
  def __repr__(self):
10702 
    L = ['%s=%r' % (key, value)
10703 
      for key, value in self.__dict__.iteritems()]
10704 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10705 
 
10706 
  def __eq__(self, other):
10707 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10708 
 
10709 
  def __ne__(self, other):
10710 
    return not (self == other)
10711 
 
10712 
class getIgnoredInventoryUpdateItemids_result:
10713 
  """
10714 
  Attributes:
10715 
   - success
10716 
  """
10717 
 
10718 
  thrift_spec = (
10719 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10720 
  )
10721 
 
10722 
  def __init__(self, success=None,):
10723 
    self.success = success
10724 
 
10725 
  def read(self, iprot):
10726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10728 
      return
10729 
    iprot.readStructBegin()
10730 
    while True:
10731 
      (fname, ftype, fid) = iprot.readFieldBegin()
10732 
      if ftype == TType.STOP:
10733 
        break
10734 
      if fid == 0:
10735 
        if ftype == TType.LIST:
10736 
          self.success = []
8182 amar.kumar 10737 
          (_etype189, _size186) = iprot.readListBegin()
10738 
          for _i190 in xrange(_size186):
10739 
            _elem191 = iprot.readI64();
10740 
            self.success.append(_elem191)
6531 vikram.rag 10741 
          iprot.readListEnd()
10742 
        else:
10743 
          iprot.skip(ftype)
10744 
      else:
10745 
        iprot.skip(ftype)
10746 
      iprot.readFieldEnd()
10747 
    iprot.readStructEnd()
10748 
 
10749 
  def write(self, oprot):
10750 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10751 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10752 
      return
10753 
    oprot.writeStructBegin('getIgnoredInventoryUpdateItemids_result')
10754 
    if self.success is not None:
10755 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10756 
      oprot.writeListBegin(TType.I64, len(self.success))
8182 amar.kumar 10757 
      for iter192 in self.success:
10758 
        oprot.writeI64(iter192)
6531 vikram.rag 10759 
      oprot.writeListEnd()
10760 
      oprot.writeFieldEnd()
10761 
    oprot.writeFieldStop()
10762 
    oprot.writeStructEnd()
10763 
 
10764 
  def validate(self):
10765 
    return
10766 
 
10767 
 
10768 
  def __repr__(self):
10769 
    L = ['%s=%r' % (key, value)
10770 
      for key, value in self.__dict__.iteritems()]
10771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10772 
 
10773 
  def __eq__(self, other):
10774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10775 
 
10776 
  def __ne__(self, other):
10777 
    return not (self == other)
6821 amar.kumar 10778 
 
10779 
class updateItemStockPurchaseParams_args:
10780 
  """
10781 
  Attributes:
10782 
   - item_id
10783 
   - numOfDaysStock
10784 
   - minStockLevel
10785 
  """
10786 
 
10787 
  thrift_spec = (
10788 
    None, # 0
10789 
    (1, TType.I64, 'item_id', None, None, ), # 1
10790 
    (2, TType.I32, 'numOfDaysStock', None, None, ), # 2
10791 
    (3, TType.I64, 'minStockLevel', None, None, ), # 3
10792 
  )
10793 
 
10794 
  def __init__(self, item_id=None, numOfDaysStock=None, minStockLevel=None,):
10795 
    self.item_id = item_id
10796 
    self.numOfDaysStock = numOfDaysStock
10797 
    self.minStockLevel = minStockLevel
10798 
 
10799 
  def read(self, iprot):
10800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10802 
      return
10803 
    iprot.readStructBegin()
10804 
    while True:
10805 
      (fname, ftype, fid) = iprot.readFieldBegin()
10806 
      if ftype == TType.STOP:
10807 
        break
10808 
      if fid == 1:
10809 
        if ftype == TType.I64:
10810 
          self.item_id = iprot.readI64();
10811 
        else:
10812 
          iprot.skip(ftype)
10813 
      elif fid == 2:
10814 
        if ftype == TType.I32:
10815 
          self.numOfDaysStock = iprot.readI32();
10816 
        else:
10817 
          iprot.skip(ftype)
10818 
      elif fid == 3:
10819 
        if ftype == TType.I64:
10820 
          self.minStockLevel = iprot.readI64();
10821 
        else:
10822 
          iprot.skip(ftype)
10823 
      else:
10824 
        iprot.skip(ftype)
10825 
      iprot.readFieldEnd()
10826 
    iprot.readStructEnd()
10827 
 
10828 
  def write(self, oprot):
10829 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10830 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10831 
      return
10832 
    oprot.writeStructBegin('updateItemStockPurchaseParams_args')
10833 
    if self.item_id is not None:
10834 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
10835 
      oprot.writeI64(self.item_id)
10836 
      oprot.writeFieldEnd()
10837 
    if self.numOfDaysStock is not None:
10838 
      oprot.writeFieldBegin('numOfDaysStock', TType.I32, 2)
10839 
      oprot.writeI32(self.numOfDaysStock)
10840 
      oprot.writeFieldEnd()
10841 
    if self.minStockLevel is not None:
10842 
      oprot.writeFieldBegin('minStockLevel', TType.I64, 3)
10843 
      oprot.writeI64(self.minStockLevel)
10844 
      oprot.writeFieldEnd()
10845 
    oprot.writeFieldStop()
10846 
    oprot.writeStructEnd()
10847 
 
10848 
  def validate(self):
10849 
    return
10850 
 
10851 
 
10852 
  def __repr__(self):
10853 
    L = ['%s=%r' % (key, value)
10854 
      for key, value in self.__dict__.iteritems()]
10855 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10856 
 
10857 
  def __eq__(self, other):
10858 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10859 
 
10860 
  def __ne__(self, other):
10861 
    return not (self == other)
10862 
 
10863 
class updateItemStockPurchaseParams_result:
10864 
 
10865 
  thrift_spec = (
10866 
  )
10867 
 
10868 
  def read(self, iprot):
10869 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10870 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10871 
      return
10872 
    iprot.readStructBegin()
10873 
    while True:
10874 
      (fname, ftype, fid) = iprot.readFieldBegin()
10875 
      if ftype == TType.STOP:
10876 
        break
10877 
      else:
10878 
        iprot.skip(ftype)
10879 
      iprot.readFieldEnd()
10880 
    iprot.readStructEnd()
10881 
 
10882 
  def write(self, oprot):
10883 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10884 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10885 
      return
10886 
    oprot.writeStructBegin('updateItemStockPurchaseParams_result')
10887 
    oprot.writeFieldStop()
10888 
    oprot.writeStructEnd()
10889 
 
10890 
  def validate(self):
10891 
    return
10892 
 
10893 
 
10894 
  def __repr__(self):
10895 
    L = ['%s=%r' % (key, value)
10896 
      for key, value in self.__dict__.iteritems()]
10897 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10898 
 
10899 
  def __eq__(self, other):
10900 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10901 
 
10902 
  def __ne__(self, other):
10903 
    return not (self == other)
10904 
 
10905 
class getItemStockPurchaseParams_args:
10906 
  """
10907 
  Attributes:
10908 
   - itemId
10909 
  """
10910 
 
10911 
  thrift_spec = (
10912 
    None, # 0
10913 
    (1, TType.I64, 'itemId', None, None, ), # 1
10914 
  )
10915 
 
10916 
  def __init__(self, itemId=None,):
10917 
    self.itemId = itemId
10918 
 
10919 
  def read(self, iprot):
10920 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10921 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10922 
      return
10923 
    iprot.readStructBegin()
10924 
    while True:
10925 
      (fname, ftype, fid) = iprot.readFieldBegin()
10926 
      if ftype == TType.STOP:
10927 
        break
10928 
      if fid == 1:
10929 
        if ftype == TType.I64:
10930 
          self.itemId = iprot.readI64();
10931 
        else:
10932 
          iprot.skip(ftype)
10933 
      else:
10934 
        iprot.skip(ftype)
10935 
      iprot.readFieldEnd()
10936 
    iprot.readStructEnd()
10937 
 
10938 
  def write(self, oprot):
10939 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10940 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10941 
      return
10942 
    oprot.writeStructBegin('getItemStockPurchaseParams_args')
10943 
    if self.itemId is not None:
10944 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
10945 
      oprot.writeI64(self.itemId)
10946 
      oprot.writeFieldEnd()
10947 
    oprot.writeFieldStop()
10948 
    oprot.writeStructEnd()
10949 
 
10950 
  def validate(self):
10951 
    return
10952 
 
10953 
 
10954 
  def __repr__(self):
10955 
    L = ['%s=%r' % (key, value)
10956 
      for key, value in self.__dict__.iteritems()]
10957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10958 
 
10959 
  def __eq__(self, other):
10960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10961 
 
10962 
  def __ne__(self, other):
10963 
    return not (self == other)
10964 
 
10965 
class getItemStockPurchaseParams_result:
10966 
  """
10967 
  Attributes:
10968 
   - success
10969 
  """
10970 
 
10971 
  thrift_spec = (
10972 
    (0, TType.STRUCT, 'success', (ItemStockPurchaseParams, ItemStockPurchaseParams.thrift_spec), None, ), # 0
10973 
  )
10974 
 
10975 
  def __init__(self, success=None,):
10976 
    self.success = success
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 == 0:
10988 
        if ftype == TType.STRUCT:
10989 
          self.success = ItemStockPurchaseParams()
10990 
          self.success.read(iprot)
10991 
        else:
10992 
          iprot.skip(ftype)
10993 
      else:
10994 
        iprot.skip(ftype)
10995 
      iprot.readFieldEnd()
10996 
    iprot.readStructEnd()
10997 
 
10998 
  def write(self, oprot):
10999 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11000 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11001 
      return
11002 
    oprot.writeStructBegin('getItemStockPurchaseParams_result')
11003 
    if self.success is not None:
11004 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11005 
      self.success.write(oprot)
11006 
      oprot.writeFieldEnd()
11007 
    oprot.writeFieldStop()
11008 
    oprot.writeStructEnd()
11009 
 
11010 
  def validate(self):
11011 
    return
11012 
 
11013 
 
11014 
  def __repr__(self):
11015 
    L = ['%s=%r' % (key, value)
11016 
      for key, value in self.__dict__.iteritems()]
11017 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11018 
 
11019 
  def __eq__(self, other):
11020 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11021 
 
11022 
  def __ne__(self, other):
11023 
    return not (self == other)
11024 
 
11025 
class addOosStatusForItem_args:
11026 
  """
11027 
  Attributes:
11028 
   - oosStatusMap
11029 
   - date
11030 
  """
11031 
 
11032 
  thrift_spec = (
11033 
    None, # 0
11034 
    (1, TType.MAP, 'oosStatusMap', (TType.I64,None,TType.BOOL,None), None, ), # 1
11035 
    (2, TType.I64, 'date', None, None, ), # 2
11036 
  )
11037 
 
11038 
  def __init__(self, oosStatusMap=None, date=None,):
11039 
    self.oosStatusMap = oosStatusMap
11040 
    self.date = date
11041 
 
11042 
  def read(self, iprot):
11043 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11044 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11045 
      return
11046 
    iprot.readStructBegin()
11047 
    while True:
11048 
      (fname, ftype, fid) = iprot.readFieldBegin()
11049 
      if ftype == TType.STOP:
11050 
        break
11051 
      if fid == 1:
11052 
        if ftype == TType.MAP:
11053 
          self.oosStatusMap = {}
8182 amar.kumar 11054 
          (_ktype194, _vtype195, _size193 ) = iprot.readMapBegin()
11055 
          for _i197 in xrange(_size193):
11056 
            _key198 = iprot.readI64();
11057 
            _val199 = iprot.readBool();
11058 
            self.oosStatusMap[_key198] = _val199
6821 amar.kumar 11059 
          iprot.readMapEnd()
11060 
        else:
11061 
          iprot.skip(ftype)
11062 
      elif fid == 2:
11063 
        if ftype == TType.I64:
11064 
          self.date = iprot.readI64();
11065 
        else:
11066 
          iprot.skip(ftype)
11067 
      else:
11068 
        iprot.skip(ftype)
11069 
      iprot.readFieldEnd()
11070 
    iprot.readStructEnd()
11071 
 
11072 
  def write(self, oprot):
11073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11075 
      return
11076 
    oprot.writeStructBegin('addOosStatusForItem_args')
11077 
    if self.oosStatusMap is not None:
11078 
      oprot.writeFieldBegin('oosStatusMap', TType.MAP, 1)
11079 
      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.oosStatusMap))
8182 amar.kumar 11080 
      for kiter200,viter201 in self.oosStatusMap.items():
11081 
        oprot.writeI64(kiter200)
11082 
        oprot.writeBool(viter201)
6821 amar.kumar 11083 
      oprot.writeMapEnd()
11084 
      oprot.writeFieldEnd()
11085 
    if self.date is not None:
11086 
      oprot.writeFieldBegin('date', TType.I64, 2)
11087 
      oprot.writeI64(self.date)
11088 
      oprot.writeFieldEnd()
11089 
    oprot.writeFieldStop()
11090 
    oprot.writeStructEnd()
11091 
 
11092 
  def validate(self):
11093 
    return
11094 
 
11095 
 
11096 
  def __repr__(self):
11097 
    L = ['%s=%r' % (key, value)
11098 
      for key, value in self.__dict__.iteritems()]
11099 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11100 
 
11101 
  def __eq__(self, other):
11102 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11103 
 
11104 
  def __ne__(self, other):
11105 
    return not (self == other)
11106 
 
11107 
class addOosStatusForItem_result:
11108 
 
11109 
  thrift_spec = (
11110 
  )
11111 
 
11112 
  def read(self, iprot):
11113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11115 
      return
11116 
    iprot.readStructBegin()
11117 
    while True:
11118 
      (fname, ftype, fid) = iprot.readFieldBegin()
11119 
      if ftype == TType.STOP:
11120 
        break
11121 
      else:
11122 
        iprot.skip(ftype)
11123 
      iprot.readFieldEnd()
11124 
    iprot.readStructEnd()
11125 
 
11126 
  def write(self, oprot):
11127 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11128 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11129 
      return
11130 
    oprot.writeStructBegin('addOosStatusForItem_result')
11131 
    oprot.writeFieldStop()
11132 
    oprot.writeStructEnd()
11133 
 
11134 
  def validate(self):
11135 
    return
11136 
 
11137 
 
11138 
  def __repr__(self):
11139 
    L = ['%s=%r' % (key, value)
11140 
      for key, value in self.__dict__.iteritems()]
11141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11142 
 
11143 
  def __eq__(self, other):
11144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11145 
 
11146 
  def __ne__(self, other):
11147 
    return not (self == other)
6832 amar.kumar 11148 
 
11149 
class getOosStatusesForXDaysForItem_args:
11150 
  """
11151 
  Attributes:
11152 
   - itemId
9762 amar.kumar 11153 
   - sourceId
6832 amar.kumar 11154 
   - days
11155 
  """
11156 
 
11157 
  thrift_spec = (
11158 
    None, # 0
11159 
    (1, TType.I64, 'itemId', None, None, ), # 1
9762 amar.kumar 11160 
    (2, TType.I32, 'sourceId', None, None, ), # 2
11161 
    (3, TType.I32, 'days', None, None, ), # 3
6832 amar.kumar 11162 
  )
11163 
 
9762 amar.kumar 11164 
  def __init__(self, itemId=None, sourceId=None, days=None,):
6832 amar.kumar 11165 
    self.itemId = itemId
9762 amar.kumar 11166 
    self.sourceId = sourceId
6832 amar.kumar 11167 
    self.days = days
11168 
 
11169 
  def read(self, iprot):
11170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11172 
      return
11173 
    iprot.readStructBegin()
11174 
    while True:
11175 
      (fname, ftype, fid) = iprot.readFieldBegin()
11176 
      if ftype == TType.STOP:
11177 
        break
11178 
      if fid == 1:
11179 
        if ftype == TType.I64:
11180 
          self.itemId = iprot.readI64();
11181 
        else:
11182 
          iprot.skip(ftype)
11183 
      elif fid == 2:
11184 
        if ftype == TType.I32:
9762 amar.kumar 11185 
          self.sourceId = iprot.readI32();
11186 
        else:
11187 
          iprot.skip(ftype)
11188 
      elif fid == 3:
11189 
        if ftype == TType.I32:
6832 amar.kumar 11190 
          self.days = iprot.readI32();
11191 
        else:
11192 
          iprot.skip(ftype)
11193 
      else:
11194 
        iprot.skip(ftype)
11195 
      iprot.readFieldEnd()
11196 
    iprot.readStructEnd()
11197 
 
11198 
  def write(self, oprot):
11199 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11200 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11201 
      return
11202 
    oprot.writeStructBegin('getOosStatusesForXDaysForItem_args')
11203 
    if self.itemId is not None:
11204 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11205 
      oprot.writeI64(self.itemId)
11206 
      oprot.writeFieldEnd()
9762 amar.kumar 11207 
    if self.sourceId is not None:
11208 
      oprot.writeFieldBegin('sourceId', TType.I32, 2)
11209 
      oprot.writeI32(self.sourceId)
11210 
      oprot.writeFieldEnd()
6832 amar.kumar 11211 
    if self.days is not None:
9762 amar.kumar 11212 
      oprot.writeFieldBegin('days', TType.I32, 3)
6832 amar.kumar 11213 
      oprot.writeI32(self.days)
11214 
      oprot.writeFieldEnd()
11215 
    oprot.writeFieldStop()
11216 
    oprot.writeStructEnd()
11217 
 
11218 
  def validate(self):
11219 
    return
11220 
 
11221 
 
11222 
  def __repr__(self):
11223 
    L = ['%s=%r' % (key, value)
11224 
      for key, value in self.__dict__.iteritems()]
11225 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11226 
 
11227 
  def __eq__(self, other):
11228 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11229 
 
11230 
  def __ne__(self, other):
11231 
    return not (self == other)
11232 
 
11233 
class getOosStatusesForXDaysForItem_result:
11234 
  """
11235 
  Attributes:
11236 
   - success
11237 
  """
11238 
 
11239 
  thrift_spec = (
11240 
    (0, TType.LIST, 'success', (TType.STRUCT,(OOSStatus, OOSStatus.thrift_spec)), None, ), # 0
11241 
  )
11242 
 
11243 
  def __init__(self, success=None,):
11244 
    self.success = success
11245 
 
11246 
  def read(self, iprot):
11247 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11248 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11249 
      return
11250 
    iprot.readStructBegin()
11251 
    while True:
11252 
      (fname, ftype, fid) = iprot.readFieldBegin()
11253 
      if ftype == TType.STOP:
11254 
        break
11255 
      if fid == 0:
11256 
        if ftype == TType.LIST:
11257 
          self.success = []
8182 amar.kumar 11258 
          (_etype205, _size202) = iprot.readListBegin()
11259 
          for _i206 in xrange(_size202):
11260 
            _elem207 = OOSStatus()
11261 
            _elem207.read(iprot)
11262 
            self.success.append(_elem207)
6832 amar.kumar 11263 
          iprot.readListEnd()
11264 
        else:
11265 
          iprot.skip(ftype)
11266 
      else:
11267 
        iprot.skip(ftype)
11268 
      iprot.readFieldEnd()
11269 
    iprot.readStructEnd()
11270 
 
11271 
  def write(self, oprot):
11272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11274 
      return
11275 
    oprot.writeStructBegin('getOosStatusesForXDaysForItem_result')
11276 
    if self.success is not None:
11277 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11278 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 11279 
      for iter208 in self.success:
11280 
        iter208.write(oprot)
6832 amar.kumar 11281 
      oprot.writeListEnd()
11282 
      oprot.writeFieldEnd()
11283 
    oprot.writeFieldStop()
11284 
    oprot.writeStructEnd()
11285 
 
11286 
  def validate(self):
11287 
    return
11288 
 
11289 
 
11290 
  def __repr__(self):
11291 
    L = ['%s=%r' % (key, value)
11292 
      for key, value in self.__dict__.iteritems()]
11293 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11294 
 
11295 
  def __eq__(self, other):
11296 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11297 
 
11298 
  def __ne__(self, other):
11299 
    return not (self == other)
6857 amar.kumar 11300 
 
10126 amar.kumar 11301 
class getOosStatusesForXDays_args:
11302 
  """
11303 
  Attributes:
11304 
   - sourceId
11305 
   - days
11306 
  """
6857 amar.kumar 11307 
 
11308 
  thrift_spec = (
10126 amar.kumar 11309 
    None, # 0
11310 
    (1, TType.I32, 'sourceId', None, None, ), # 1
11311 
    (2, TType.I32, 'days', None, None, ), # 2
6857 amar.kumar 11312 
  )
11313 
 
10126 amar.kumar 11314 
  def __init__(self, sourceId=None, days=None,):
11315 
    self.sourceId = sourceId
11316 
    self.days = days
11317 
 
6857 amar.kumar 11318 
  def read(self, iprot):
11319 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11320 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11321 
      return
11322 
    iprot.readStructBegin()
11323 
    while True:
11324 
      (fname, ftype, fid) = iprot.readFieldBegin()
11325 
      if ftype == TType.STOP:
11326 
        break
10126 amar.kumar 11327 
      if fid == 1:
11328 
        if ftype == TType.I32:
11329 
          self.sourceId = iprot.readI32();
11330 
        else:
11331 
          iprot.skip(ftype)
11332 
      elif fid == 2:
11333 
        if ftype == TType.I32:
11334 
          self.days = iprot.readI32();
11335 
        else:
11336 
          iprot.skip(ftype)
6857 amar.kumar 11337 
      else:
11338 
        iprot.skip(ftype)
11339 
      iprot.readFieldEnd()
11340 
    iprot.readStructEnd()
11341 
 
11342 
  def write(self, oprot):
11343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11345 
      return
10126 amar.kumar 11346 
    oprot.writeStructBegin('getOosStatusesForXDays_args')
11347 
    if self.sourceId is not None:
11348 
      oprot.writeFieldBegin('sourceId', TType.I32, 1)
11349 
      oprot.writeI32(self.sourceId)
11350 
      oprot.writeFieldEnd()
11351 
    if self.days is not None:
11352 
      oprot.writeFieldBegin('days', TType.I32, 2)
11353 
      oprot.writeI32(self.days)
11354 
      oprot.writeFieldEnd()
6857 amar.kumar 11355 
    oprot.writeFieldStop()
11356 
    oprot.writeStructEnd()
11357 
 
11358 
  def validate(self):
11359 
    return
11360 
 
11361 
 
11362 
  def __repr__(self):
11363 
    L = ['%s=%r' % (key, value)
11364 
      for key, value in self.__dict__.iteritems()]
11365 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11366 
 
11367 
  def __eq__(self, other):
11368 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11369 
 
11370 
  def __ne__(self, other):
11371 
    return not (self == other)
11372 
 
10126 amar.kumar 11373 
class getOosStatusesForXDays_result:
6857 amar.kumar 11374 
  """
11375 
  Attributes:
11376 
   - success
11377 
  """
11378 
 
11379 
  thrift_spec = (
10126 amar.kumar 11380 
    (0, TType.LIST, 'success', (TType.STRUCT,(OOSStatus, OOSStatus.thrift_spec)), None, ), # 0
6857 amar.kumar 11381 
  )
11382 
 
11383 
  def __init__(self, success=None,):
11384 
    self.success = success
11385 
 
11386 
  def read(self, iprot):
11387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11389 
      return
11390 
    iprot.readStructBegin()
11391 
    while True:
11392 
      (fname, ftype, fid) = iprot.readFieldBegin()
11393 
      if ftype == TType.STOP:
11394 
        break
11395 
      if fid == 0:
11396 
        if ftype == TType.LIST:
11397 
          self.success = []
8182 amar.kumar 11398 
          (_etype212, _size209) = iprot.readListBegin()
11399 
          for _i213 in xrange(_size209):
10126 amar.kumar 11400 
            _elem214 = OOSStatus()
8182 amar.kumar 11401 
            _elem214.read(iprot)
11402 
            self.success.append(_elem214)
6857 amar.kumar 11403 
          iprot.readListEnd()
11404 
        else:
11405 
          iprot.skip(ftype)
11406 
      else:
11407 
        iprot.skip(ftype)
11408 
      iprot.readFieldEnd()
11409 
    iprot.readStructEnd()
11410 
 
11411 
  def write(self, oprot):
11412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11414 
      return
10126 amar.kumar 11415 
    oprot.writeStructBegin('getOosStatusesForXDays_result')
6857 amar.kumar 11416 
    if self.success is not None:
11417 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11418 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 11419 
      for iter215 in self.success:
11420 
        iter215.write(oprot)
6857 amar.kumar 11421 
      oprot.writeListEnd()
11422 
      oprot.writeFieldEnd()
11423 
    oprot.writeFieldStop()
11424 
    oprot.writeStructEnd()
11425 
 
11426 
  def validate(self):
11427 
    return
11428 
 
11429 
 
11430 
  def __repr__(self):
11431 
    L = ['%s=%r' % (key, value)
11432 
      for key, value in self.__dict__.iteritems()]
11433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11434 
 
11435 
  def __eq__(self, other):
11436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11437 
 
11438 
  def __ne__(self, other):
11439 
    return not (self == other)
7149 amar.kumar 11440 
 
10126 amar.kumar 11441 
class getAllVendorItemPricing_args:
11442 
  """
11443 
  Attributes:
11444 
   - itemId
11445 
   - vendorId
11446 
  """
7149 amar.kumar 11447 
 
11448 
  thrift_spec = (
10126 amar.kumar 11449 
    None, # 0
11450 
    (1, TType.I64, 'itemId', None, None, ), # 1
11451 
    (2, TType.I64, 'vendorId', None, None, ), # 2
7149 amar.kumar 11452 
  )
11453 
 
10126 amar.kumar 11454 
  def __init__(self, itemId=None, vendorId=None,):
11455 
    self.itemId = itemId
11456 
    self.vendorId = vendorId
11457 
 
7149 amar.kumar 11458 
  def read(self, iprot):
11459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11461 
      return
11462 
    iprot.readStructBegin()
11463 
    while True:
11464 
      (fname, ftype, fid) = iprot.readFieldBegin()
11465 
      if ftype == TType.STOP:
11466 
        break
10126 amar.kumar 11467 
      if fid == 1:
11468 
        if ftype == TType.I64:
11469 
          self.itemId = iprot.readI64();
11470 
        else:
11471 
          iprot.skip(ftype)
11472 
      elif fid == 2:
11473 
        if ftype == TType.I64:
11474 
          self.vendorId = iprot.readI64();
11475 
        else:
11476 
          iprot.skip(ftype)
7149 amar.kumar 11477 
      else:
11478 
        iprot.skip(ftype)
11479 
      iprot.readFieldEnd()
11480 
    iprot.readStructEnd()
11481 
 
11482 
  def write(self, oprot):
11483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11485 
      return
10126 amar.kumar 11486 
    oprot.writeStructBegin('getAllVendorItemPricing_args')
11487 
    if self.itemId is not None:
11488 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11489 
      oprot.writeI64(self.itemId)
11490 
      oprot.writeFieldEnd()
11491 
    if self.vendorId is not None:
11492 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
11493 
      oprot.writeI64(self.vendorId)
11494 
      oprot.writeFieldEnd()
7149 amar.kumar 11495 
    oprot.writeFieldStop()
11496 
    oprot.writeStructEnd()
11497 
 
11498 
  def validate(self):
11499 
    return
11500 
 
11501 
 
11502 
  def __repr__(self):
11503 
    L = ['%s=%r' % (key, value)
11504 
      for key, value in self.__dict__.iteritems()]
11505 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11506 
 
11507 
  def __eq__(self, other):
11508 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11509 
 
11510 
  def __ne__(self, other):
11511 
    return not (self == other)
11512 
 
10126 amar.kumar 11513 
class getAllVendorItemPricing_result:
7149 amar.kumar 11514 
  """
11515 
  Attributes:
11516 
   - success
11517 
  """
11518 
 
11519 
  thrift_spec = (
10126 amar.kumar 11520 
    (0, TType.LIST, 'success', (TType.STRUCT,(VendorItemPricing, VendorItemPricing.thrift_spec)), None, ), # 0
7149 amar.kumar 11521 
  )
11522 
 
11523 
  def __init__(self, success=None,):
11524 
    self.success = success
11525 
 
11526 
  def read(self, iprot):
11527 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11528 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11529 
      return
11530 
    iprot.readStructBegin()
11531 
    while True:
11532 
      (fname, ftype, fid) = iprot.readFieldBegin()
11533 
      if ftype == TType.STOP:
11534 
        break
11535 
      if fid == 0:
11536 
        if ftype == TType.LIST:
11537 
          self.success = []
8182 amar.kumar 11538 
          (_etype219, _size216) = iprot.readListBegin()
11539 
          for _i220 in xrange(_size216):
10126 amar.kumar 11540 
            _elem221 = VendorItemPricing()
8182 amar.kumar 11541 
            _elem221.read(iprot)
11542 
            self.success.append(_elem221)
7149 amar.kumar 11543 
          iprot.readListEnd()
11544 
        else:
11545 
          iprot.skip(ftype)
11546 
      else:
11547 
        iprot.skip(ftype)
11548 
      iprot.readFieldEnd()
11549 
    iprot.readStructEnd()
11550 
 
11551 
  def write(self, oprot):
11552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11554 
      return
10126 amar.kumar 11555 
    oprot.writeStructBegin('getAllVendorItemPricing_result')
7149 amar.kumar 11556 
    if self.success is not None:
11557 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11558 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 11559 
      for iter222 in self.success:
11560 
        iter222.write(oprot)
7149 amar.kumar 11561 
      oprot.writeListEnd()
11562 
      oprot.writeFieldEnd()
11563 
    oprot.writeFieldStop()
11564 
    oprot.writeStructEnd()
11565 
 
11566 
  def validate(self):
11567 
    return
11568 
 
11569 
 
11570 
  def __repr__(self):
11571 
    L = ['%s=%r' % (key, value)
11572 
      for key, value in self.__dict__.iteritems()]
11573 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11574 
 
11575 
  def __eq__(self, other):
11576 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11577 
 
11578 
  def __ne__(self, other):
11579 
    return not (self == other)
7281 kshitij.so 11580 
 
10126 amar.kumar 11581 
class getNonZeroItemStockPurchaseParams_args:
11582 
 
11583 
  thrift_spec = (
11584 
  )
11585 
 
11586 
  def read(self, iprot):
11587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11589 
      return
11590 
    iprot.readStructBegin()
11591 
    while True:
11592 
      (fname, ftype, fid) = iprot.readFieldBegin()
11593 
      if ftype == TType.STOP:
11594 
        break
11595 
      else:
11596 
        iprot.skip(ftype)
11597 
      iprot.readFieldEnd()
11598 
    iprot.readStructEnd()
11599 
 
11600 
  def write(self, oprot):
11601 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11602 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11603 
      return
11604 
    oprot.writeStructBegin('getNonZeroItemStockPurchaseParams_args')
11605 
    oprot.writeFieldStop()
11606 
    oprot.writeStructEnd()
11607 
 
11608 
  def validate(self):
11609 
    return
11610 
 
11611 
 
11612 
  def __repr__(self):
11613 
    L = ['%s=%r' % (key, value)
11614 
      for key, value in self.__dict__.iteritems()]
11615 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11616 
 
11617 
  def __eq__(self, other):
11618 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11619 
 
11620 
  def __ne__(self, other):
11621 
    return not (self == other)
11622 
 
11623 
class getNonZeroItemStockPurchaseParams_result:
11624 
  """
11625 
  Attributes:
11626 
   - success
11627 
  """
11628 
 
11629 
  thrift_spec = (
11630 
    (0, TType.LIST, 'success', (TType.STRUCT,(ItemStockPurchaseParams, ItemStockPurchaseParams.thrift_spec)), None, ), # 0
11631 
  )
11632 
 
11633 
  def __init__(self, success=None,):
11634 
    self.success = success
11635 
 
11636 
  def read(self, iprot):
11637 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11638 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11639 
      return
11640 
    iprot.readStructBegin()
11641 
    while True:
11642 
      (fname, ftype, fid) = iprot.readFieldBegin()
11643 
      if ftype == TType.STOP:
11644 
        break
11645 
      if fid == 0:
11646 
        if ftype == TType.LIST:
11647 
          self.success = []
11648 
          (_etype226, _size223) = iprot.readListBegin()
11649 
          for _i227 in xrange(_size223):
11650 
            _elem228 = ItemStockPurchaseParams()
11651 
            _elem228.read(iprot)
11652 
            self.success.append(_elem228)
11653 
          iprot.readListEnd()
11654 
        else:
11655 
          iprot.skip(ftype)
11656 
      else:
11657 
        iprot.skip(ftype)
11658 
      iprot.readFieldEnd()
11659 
    iprot.readStructEnd()
11660 
 
11661 
  def write(self, oprot):
11662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11664 
      return
11665 
    oprot.writeStructBegin('getNonZeroItemStockPurchaseParams_result')
11666 
    if self.success is not None:
11667 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11668 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11669 
      for iter229 in self.success:
11670 
        iter229.write(oprot)
11671 
      oprot.writeListEnd()
11672 
      oprot.writeFieldEnd()
11673 
    oprot.writeFieldStop()
11674 
    oprot.writeStructEnd()
11675 
 
11676 
  def validate(self):
11677 
    return
11678 
 
11679 
 
11680 
  def __repr__(self):
11681 
    L = ['%s=%r' % (key, value)
11682 
      for key, value in self.__dict__.iteritems()]
11683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11684 
 
11685 
  def __eq__(self, other):
11686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11687 
 
11688 
  def __ne__(self, other):
11689 
    return not (self == other)
11690 
 
11691 
class getBillableInventoryAndPendingOrders_args:
11692 
 
11693 
  thrift_spec = (
11694 
  )
11695 
 
11696 
  def read(self, iprot):
11697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11699 
      return
11700 
    iprot.readStructBegin()
11701 
    while True:
11702 
      (fname, ftype, fid) = iprot.readFieldBegin()
11703 
      if ftype == TType.STOP:
11704 
        break
11705 
      else:
11706 
        iprot.skip(ftype)
11707 
      iprot.readFieldEnd()
11708 
    iprot.readStructEnd()
11709 
 
11710 
  def write(self, oprot):
11711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11713 
      return
11714 
    oprot.writeStructBegin('getBillableInventoryAndPendingOrders_args')
11715 
    oprot.writeFieldStop()
11716 
    oprot.writeStructEnd()
11717 
 
11718 
  def validate(self):
11719 
    return
11720 
 
11721 
 
11722 
  def __repr__(self):
11723 
    L = ['%s=%r' % (key, value)
11724 
      for key, value in self.__dict__.iteritems()]
11725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11726 
 
11727 
  def __eq__(self, other):
11728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11729 
 
11730 
  def __ne__(self, other):
11731 
    return not (self == other)
11732 
 
11733 
class getBillableInventoryAndPendingOrders_result:
11734 
  """
11735 
  Attributes:
11736 
   - success
11737 
  """
11738 
 
11739 
  thrift_spec = (
11740 
    (0, TType.LIST, 'success', (TType.STRUCT,(AvailableAndReservedStock, AvailableAndReservedStock.thrift_spec)), None, ), # 0
11741 
  )
11742 
 
11743 
  def __init__(self, success=None,):
11744 
    self.success = success
11745 
 
11746 
  def read(self, iprot):
11747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11749 
      return
11750 
    iprot.readStructBegin()
11751 
    while True:
11752 
      (fname, ftype, fid) = iprot.readFieldBegin()
11753 
      if ftype == TType.STOP:
11754 
        break
11755 
      if fid == 0:
11756 
        if ftype == TType.LIST:
11757 
          self.success = []
11758 
          (_etype233, _size230) = iprot.readListBegin()
11759 
          for _i234 in xrange(_size230):
11760 
            _elem235 = AvailableAndReservedStock()
11761 
            _elem235.read(iprot)
11762 
            self.success.append(_elem235)
11763 
          iprot.readListEnd()
11764 
        else:
11765 
          iprot.skip(ftype)
11766 
      else:
11767 
        iprot.skip(ftype)
11768 
      iprot.readFieldEnd()
11769 
    iprot.readStructEnd()
11770 
 
11771 
  def write(self, oprot):
11772 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11773 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11774 
      return
11775 
    oprot.writeStructBegin('getBillableInventoryAndPendingOrders_result')
11776 
    if self.success is not None:
11777 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11778 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11779 
      for iter236 in self.success:
11780 
        iter236.write(oprot)
11781 
      oprot.writeListEnd()
11782 
      oprot.writeFieldEnd()
11783 
    oprot.writeFieldStop()
11784 
    oprot.writeStructEnd()
11785 
 
11786 
  def validate(self):
11787 
    return
11788 
 
11789 
 
11790 
  def __repr__(self):
11791 
    L = ['%s=%r' % (key, value)
11792 
      for key, value in self.__dict__.iteritems()]
11793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11794 
 
11795 
  def __eq__(self, other):
11796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11797 
 
11798 
  def __ne__(self, other):
11799 
    return not (self == other)
11800 
 
7281 kshitij.so 11801 
class getWarehouseName_args:
11802 
  """
11803 
  Attributes:
11804 
   - warehouse_id
11805 
  """
11806 
 
11807 
  thrift_spec = (
11808 
    None, # 0
11809 
    (1, TType.I64, 'warehouse_id', None, None, ), # 1
11810 
  )
11811 
 
11812 
  def __init__(self, warehouse_id=None,):
11813 
    self.warehouse_id = warehouse_id
11814 
 
11815 
  def read(self, iprot):
11816 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11817 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11818 
      return
11819 
    iprot.readStructBegin()
11820 
    while True:
11821 
      (fname, ftype, fid) = iprot.readFieldBegin()
11822 
      if ftype == TType.STOP:
11823 
        break
11824 
      if fid == 1:
11825 
        if ftype == TType.I64:
11826 
          self.warehouse_id = iprot.readI64();
11827 
        else:
11828 
          iprot.skip(ftype)
11829 
      else:
11830 
        iprot.skip(ftype)
11831 
      iprot.readFieldEnd()
11832 
    iprot.readStructEnd()
11833 
 
11834 
  def write(self, oprot):
11835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11837 
      return
11838 
    oprot.writeStructBegin('getWarehouseName_args')
11839 
    if self.warehouse_id is not None:
11840 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 1)
11841 
      oprot.writeI64(self.warehouse_id)
11842 
      oprot.writeFieldEnd()
11843 
    oprot.writeFieldStop()
11844 
    oprot.writeStructEnd()
11845 
 
11846 
  def validate(self):
11847 
    return
11848 
 
11849 
 
11850 
  def __repr__(self):
11851 
    L = ['%s=%r' % (key, value)
11852 
      for key, value in self.__dict__.iteritems()]
11853 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11854 
 
11855 
  def __eq__(self, other):
11856 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11857 
 
11858 
  def __ne__(self, other):
11859 
    return not (self == other)
11860 
 
11861 
class getWarehouseName_result:
11862 
  """
11863 
  Attributes:
11864 
   - success
11865 
  """
11866 
 
11867 
  thrift_spec = (
11868 
    (0, TType.STRING, 'success', None, None, ), # 0
11869 
  )
11870 
 
11871 
  def __init__(self, success=None,):
11872 
    self.success = success
11873 
 
11874 
  def read(self, iprot):
11875 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11876 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11877 
      return
11878 
    iprot.readStructBegin()
11879 
    while True:
11880 
      (fname, ftype, fid) = iprot.readFieldBegin()
11881 
      if ftype == TType.STOP:
11882 
        break
11883 
      if fid == 0:
11884 
        if ftype == TType.STRING:
11885 
          self.success = iprot.readString();
11886 
        else:
11887 
          iprot.skip(ftype)
11888 
      else:
11889 
        iprot.skip(ftype)
11890 
      iprot.readFieldEnd()
11891 
    iprot.readStructEnd()
11892 
 
11893 
  def write(self, oprot):
11894 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11895 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11896 
      return
11897 
    oprot.writeStructBegin('getWarehouseName_result')
11898 
    if self.success is not None:
11899 
      oprot.writeFieldBegin('success', TType.STRING, 0)
11900 
      oprot.writeString(self.success)
11901 
      oprot.writeFieldEnd()
11902 
    oprot.writeFieldStop()
11903 
    oprot.writeStructEnd()
11904 
 
11905 
  def validate(self):
11906 
    return
11907 
 
11908 
 
11909 
  def __repr__(self):
11910 
    L = ['%s=%r' % (key, value)
11911 
      for key, value in self.__dict__.iteritems()]
11912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11913 
 
11914 
  def __eq__(self, other):
11915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11916 
 
11917 
  def __ne__(self, other):
11918 
    return not (self == other)
11919 
 
11920 
class getAmazonInventoryForItem_args:
11921 
  """
11922 
  Attributes:
11923 
   - item_id
11924 
  """
11925 
 
11926 
  thrift_spec = (
11927 
    None, # 0
11928 
    (1, TType.I64, 'item_id', None, None, ), # 1
11929 
  )
11930 
 
11931 
  def __init__(self, item_id=None,):
11932 
    self.item_id = item_id
11933 
 
11934 
  def read(self, iprot):
11935 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11936 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11937 
      return
11938 
    iprot.readStructBegin()
11939 
    while True:
11940 
      (fname, ftype, fid) = iprot.readFieldBegin()
11941 
      if ftype == TType.STOP:
11942 
        break
11943 
      if fid == 1:
11944 
        if ftype == TType.I64:
11945 
          self.item_id = iprot.readI64();
11946 
        else:
11947 
          iprot.skip(ftype)
11948 
      else:
11949 
        iprot.skip(ftype)
11950 
      iprot.readFieldEnd()
11951 
    iprot.readStructEnd()
11952 
 
11953 
  def write(self, oprot):
11954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11956 
      return
11957 
    oprot.writeStructBegin('getAmazonInventoryForItem_args')
11958 
    if self.item_id is not None:
11959 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
11960 
      oprot.writeI64(self.item_id)
11961 
      oprot.writeFieldEnd()
11962 
    oprot.writeFieldStop()
11963 
    oprot.writeStructEnd()
11964 
 
11965 
  def validate(self):
11966 
    return
11967 
 
11968 
 
11969 
  def __repr__(self):
11970 
    L = ['%s=%r' % (key, value)
11971 
      for key, value in self.__dict__.iteritems()]
11972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11973 
 
11974 
  def __eq__(self, other):
11975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11976 
 
11977 
  def __ne__(self, other):
11978 
    return not (self == other)
11979 
 
11980 
class getAmazonInventoryForItem_result:
11981 
  """
11982 
  Attributes:
11983 
   - success
11984 
  """
11985 
 
11986 
  thrift_spec = (
11987 
    (0, TType.STRUCT, 'success', (AmazonInventorySnapshot, AmazonInventorySnapshot.thrift_spec), None, ), # 0
11988 
  )
11989 
 
11990 
  def __init__(self, success=None,):
11991 
    self.success = success
11992 
 
11993 
  def read(self, iprot):
11994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11996 
      return
11997 
    iprot.readStructBegin()
11998 
    while True:
11999 
      (fname, ftype, fid) = iprot.readFieldBegin()
12000 
      if ftype == TType.STOP:
12001 
        break
12002 
      if fid == 0:
12003 
        if ftype == TType.STRUCT:
12004 
          self.success = AmazonInventorySnapshot()
12005 
          self.success.read(iprot)
12006 
        else:
12007 
          iprot.skip(ftype)
12008 
      else:
12009 
        iprot.skip(ftype)
12010 
      iprot.readFieldEnd()
12011 
    iprot.readStructEnd()
12012 
 
12013 
  def write(self, oprot):
12014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12016 
      return
12017 
    oprot.writeStructBegin('getAmazonInventoryForItem_result')
12018 
    if self.success is not None:
12019 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12020 
      self.success.write(oprot)
12021 
      oprot.writeFieldEnd()
12022 
    oprot.writeFieldStop()
12023 
    oprot.writeStructEnd()
12024 
 
12025 
  def validate(self):
12026 
    return
12027 
 
12028 
 
12029 
  def __repr__(self):
12030 
    L = ['%s=%r' % (key, value)
12031 
      for key, value in self.__dict__.iteritems()]
12032 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12033 
 
12034 
  def __eq__(self, other):
12035 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12036 
 
12037 
  def __ne__(self, other):
12038 
    return not (self == other)
12039 
 
12040 
class getAllAmazonInventory_args:
12041 
 
12042 
  thrift_spec = (
12043 
  )
12044 
 
12045 
  def read(self, iprot):
12046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12048 
      return
12049 
    iprot.readStructBegin()
12050 
    while True:
12051 
      (fname, ftype, fid) = iprot.readFieldBegin()
12052 
      if ftype == TType.STOP:
12053 
        break
12054 
      else:
12055 
        iprot.skip(ftype)
12056 
      iprot.readFieldEnd()
12057 
    iprot.readStructEnd()
12058 
 
12059 
  def write(self, oprot):
12060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12062 
      return
12063 
    oprot.writeStructBegin('getAllAmazonInventory_args')
12064 
    oprot.writeFieldStop()
12065 
    oprot.writeStructEnd()
12066 
 
12067 
  def validate(self):
12068 
    return
12069 
 
12070 
 
12071 
  def __repr__(self):
12072 
    L = ['%s=%r' % (key, value)
12073 
      for key, value in self.__dict__.iteritems()]
12074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12075 
 
12076 
  def __eq__(self, other):
12077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12078 
 
12079 
  def __ne__(self, other):
12080 
    return not (self == other)
12081 
 
12082 
class getAllAmazonInventory_result:
12083 
  """
12084 
  Attributes:
12085 
   - success
12086 
  """
12087 
 
12088 
  thrift_spec = (
12089 
    (0, TType.LIST, 'success', (TType.STRUCT,(AmazonInventorySnapshot, AmazonInventorySnapshot.thrift_spec)), None, ), # 0
12090 
  )
12091 
 
12092 
  def __init__(self, success=None,):
12093 
    self.success = success
12094 
 
12095 
  def read(self, iprot):
12096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12098 
      return
12099 
    iprot.readStructBegin()
12100 
    while True:
12101 
      (fname, ftype, fid) = iprot.readFieldBegin()
12102 
      if ftype == TType.STOP:
12103 
        break
12104 
      if fid == 0:
12105 
        if ftype == TType.LIST:
12106 
          self.success = []
10126 amar.kumar 12107 
          (_etype240, _size237) = iprot.readListBegin()
12108 
          for _i241 in xrange(_size237):
12109 
            _elem242 = AmazonInventorySnapshot()
12110 
            _elem242.read(iprot)
12111 
            self.success.append(_elem242)
7281 kshitij.so 12112 
          iprot.readListEnd()
12113 
        else:
12114 
          iprot.skip(ftype)
12115 
      else:
12116 
        iprot.skip(ftype)
12117 
      iprot.readFieldEnd()
12118 
    iprot.readStructEnd()
12119 
 
12120 
  def write(self, oprot):
12121 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12122 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12123 
      return
12124 
    oprot.writeStructBegin('getAllAmazonInventory_result')
12125 
    if self.success is not None:
12126 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12127 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
10126 amar.kumar 12128 
      for iter243 in self.success:
12129 
        iter243.write(oprot)
7281 kshitij.so 12130 
      oprot.writeListEnd()
12131 
      oprot.writeFieldEnd()
12132 
    oprot.writeFieldStop()
12133 
    oprot.writeStructEnd()
12134 
 
12135 
  def validate(self):
12136 
    return
12137 
 
12138 
 
12139 
  def __repr__(self):
12140 
    L = ['%s=%r' % (key, value)
12141 
      for key, value in self.__dict__.iteritems()]
12142 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12143 
 
12144 
  def __eq__(self, other):
12145 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12146 
 
12147 
  def __ne__(self, other):
12148 
    return not (self == other)
12149 
 
12150 
class addOrUpdateAmazonInventoryForItem_args:
12151 
  """
12152 
  Attributes:
12153 
   - amazonInventorySnapshot
10450 vikram.rag 12154 
   - time
7281 kshitij.so 12155 
  """
12156 
 
12157 
  thrift_spec = (
12158 
    None, # 0
12159 
    (1, TType.STRUCT, 'amazonInventorySnapshot', (AmazonInventorySnapshot, AmazonInventorySnapshot.thrift_spec), None, ), # 1
10450 vikram.rag 12160 
    (2, TType.I64, 'time', None, None, ), # 2
7281 kshitij.so 12161 
  )
12162 
 
10450 vikram.rag 12163 
  def __init__(self, amazonInventorySnapshot=None, time=None,):
7281 kshitij.so 12164 
    self.amazonInventorySnapshot = amazonInventorySnapshot
10450 vikram.rag 12165 
    self.time = time
7281 kshitij.so 12166 
 
12167 
  def read(self, iprot):
12168 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12169 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12170 
      return
12171 
    iprot.readStructBegin()
12172 
    while True:
12173 
      (fname, ftype, fid) = iprot.readFieldBegin()
12174 
      if ftype == TType.STOP:
12175 
        break
12176 
      if fid == 1:
12177 
        if ftype == TType.STRUCT:
12178 
          self.amazonInventorySnapshot = AmazonInventorySnapshot()
12179 
          self.amazonInventorySnapshot.read(iprot)
12180 
        else:
12181 
          iprot.skip(ftype)
10450 vikram.rag 12182 
      elif fid == 2:
12183 
        if ftype == TType.I64:
12184 
          self.time = iprot.readI64();
12185 
        else:
12186 
          iprot.skip(ftype)
7281 kshitij.so 12187 
      else:
12188 
        iprot.skip(ftype)
12189 
      iprot.readFieldEnd()
12190 
    iprot.readStructEnd()
12191 
 
12192 
  def write(self, oprot):
12193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12195 
      return
12196 
    oprot.writeStructBegin('addOrUpdateAmazonInventoryForItem_args')
12197 
    if self.amazonInventorySnapshot is not None:
12198 
      oprot.writeFieldBegin('amazonInventorySnapshot', TType.STRUCT, 1)
12199 
      self.amazonInventorySnapshot.write(oprot)
12200 
      oprot.writeFieldEnd()
10450 vikram.rag 12201 
    if self.time is not None:
12202 
      oprot.writeFieldBegin('time', TType.I64, 2)
12203 
      oprot.writeI64(self.time)
12204 
      oprot.writeFieldEnd()
7281 kshitij.so 12205 
    oprot.writeFieldStop()
12206 
    oprot.writeStructEnd()
12207 
 
12208 
  def validate(self):
12209 
    return
12210 
 
12211 
 
12212 
  def __repr__(self):
12213 
    L = ['%s=%r' % (key, value)
12214 
      for key, value in self.__dict__.iteritems()]
12215 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12216 
 
12217 
  def __eq__(self, other):
12218 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12219 
 
12220 
  def __ne__(self, other):
12221 
    return not (self == other)
12222 
 
12223 
class addOrUpdateAmazonInventoryForItem_result:
12224 
 
12225 
  thrift_spec = (
12226 
  )
12227 
 
12228 
  def read(self, iprot):
12229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12231 
      return
12232 
    iprot.readStructBegin()
12233 
    while True:
12234 
      (fname, ftype, fid) = iprot.readFieldBegin()
12235 
      if ftype == TType.STOP:
12236 
        break
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('addOrUpdateAmazonInventoryForItem_result')
12247 
    oprot.writeFieldStop()
12248 
    oprot.writeStructEnd()
12249 
 
12250 
  def validate(self):
12251 
    return
12252 
 
12253 
 
12254 
  def __repr__(self):
12255 
    L = ['%s=%r' % (key, value)
12256 
      for key, value in self.__dict__.iteritems()]
12257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12258 
 
12259 
  def __eq__(self, other):
12260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12261 
 
12262 
  def __ne__(self, other):
12263 
    return not (self == other)
7972 amar.kumar 12264 
 
12265 
class getLastNdaySaleForItem_args:
12266 
  """
12267 
  Attributes:
12268 
   - itemId
12269 
   - numberOfDays
12270 
  """
12271 
 
12272 
  thrift_spec = (
12273 
    None, # 0
12274 
    (1, TType.I64, 'itemId', None, None, ), # 1
12275 
    (2, TType.I64, 'numberOfDays', None, None, ), # 2
12276 
  )
12277 
 
12278 
  def __init__(self, itemId=None, numberOfDays=None,):
12279 
    self.itemId = itemId
12280 
    self.numberOfDays = numberOfDays
12281 
 
12282 
  def read(self, iprot):
12283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12285 
      return
12286 
    iprot.readStructBegin()
12287 
    while True:
12288 
      (fname, ftype, fid) = iprot.readFieldBegin()
12289 
      if ftype == TType.STOP:
12290 
        break
12291 
      if fid == 1:
12292 
        if ftype == TType.I64:
12293 
          self.itemId = iprot.readI64();
12294 
        else:
12295 
          iprot.skip(ftype)
12296 
      elif fid == 2:
12297 
        if ftype == TType.I64:
12298 
          self.numberOfDays = iprot.readI64();
12299 
        else:
12300 
          iprot.skip(ftype)
12301 
      else:
12302 
        iprot.skip(ftype)
12303 
      iprot.readFieldEnd()
12304 
    iprot.readStructEnd()
12305 
 
12306 
  def write(self, oprot):
12307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12309 
      return
12310 
    oprot.writeStructBegin('getLastNdaySaleForItem_args')
12311 
    if self.itemId is not None:
12312 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12313 
      oprot.writeI64(self.itemId)
12314 
      oprot.writeFieldEnd()
12315 
    if self.numberOfDays is not None:
12316 
      oprot.writeFieldBegin('numberOfDays', TType.I64, 2)
12317 
      oprot.writeI64(self.numberOfDays)
12318 
      oprot.writeFieldEnd()
12319 
    oprot.writeFieldStop()
12320 
    oprot.writeStructEnd()
12321 
 
12322 
  def validate(self):
12323 
    return
12324 
 
12325 
 
12326 
  def __repr__(self):
12327 
    L = ['%s=%r' % (key, value)
12328 
      for key, value in self.__dict__.iteritems()]
12329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12330 
 
12331 
  def __eq__(self, other):
12332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12333 
 
12334 
  def __ne__(self, other):
12335 
    return not (self == other)
12336 
 
12337 
class getLastNdaySaleForItem_result:
12338 
  """
12339 
  Attributes:
12340 
   - success
12341 
  """
12342 
 
12343 
  thrift_spec = (
12344 
    (0, TType.STRING, 'success', None, None, ), # 0
12345 
  )
12346 
 
12347 
  def __init__(self, success=None,):
12348 
    self.success = success
12349 
 
12350 
  def read(self, iprot):
12351 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12352 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12353 
      return
12354 
    iprot.readStructBegin()
12355 
    while True:
12356 
      (fname, ftype, fid) = iprot.readFieldBegin()
12357 
      if ftype == TType.STOP:
12358 
        break
12359 
      if fid == 0:
12360 
        if ftype == TType.STRING:
12361 
          self.success = iprot.readString();
12362 
        else:
12363 
          iprot.skip(ftype)
12364 
      else:
12365 
        iprot.skip(ftype)
12366 
      iprot.readFieldEnd()
12367 
    iprot.readStructEnd()
12368 
 
12369 
  def write(self, oprot):
12370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12372 
      return
12373 
    oprot.writeStructBegin('getLastNdaySaleForItem_result')
12374 
    if self.success is not None:
12375 
      oprot.writeFieldBegin('success', TType.STRING, 0)
12376 
      oprot.writeString(self.success)
12377 
      oprot.writeFieldEnd()
12378 
    oprot.writeFieldStop()
12379 
    oprot.writeStructEnd()
12380 
 
12381 
  def validate(self):
12382 
    return
12383 
 
12384 
 
12385 
  def __repr__(self):
12386 
    L = ['%s=%r' % (key, value)
12387 
      for key, value in self.__dict__.iteritems()]
12388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12389 
 
12390 
  def __eq__(self, other):
12391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12392 
 
12393 
  def __ne__(self, other):
12394 
    return not (self == other)
8182 amar.kumar 12395 
 
8282 kshitij.so 12396 
class addOrUpdateAmazonFbaInventory_args:
12397 
  """
12398 
  Attributes:
12399 
   - amazonfbainventorysnapshot
12400 
  """
12401 
 
12402 
  thrift_spec = (
12403 
    None, # 0
12404 
    (1, TType.STRUCT, 'amazonfbainventorysnapshot', (AmazonFbaInventorySnapshot, AmazonFbaInventorySnapshot.thrift_spec), None, ), # 1
12405 
  )
12406 
 
12407 
  def __init__(self, amazonfbainventorysnapshot=None,):
12408 
    self.amazonfbainventorysnapshot = amazonfbainventorysnapshot
12409 
 
12410 
  def read(self, iprot):
12411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12413 
      return
12414 
    iprot.readStructBegin()
12415 
    while True:
12416 
      (fname, ftype, fid) = iprot.readFieldBegin()
12417 
      if ftype == TType.STOP:
12418 
        break
12419 
      if fid == 1:
12420 
        if ftype == TType.STRUCT:
12421 
          self.amazonfbainventorysnapshot = AmazonFbaInventorySnapshot()
12422 
          self.amazonfbainventorysnapshot.read(iprot)
12423 
        else:
12424 
          iprot.skip(ftype)
12425 
      else:
12426 
        iprot.skip(ftype)
12427 
      iprot.readFieldEnd()
12428 
    iprot.readStructEnd()
12429 
 
12430 
  def write(self, oprot):
12431 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12432 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12433 
      return
12434 
    oprot.writeStructBegin('addOrUpdateAmazonFbaInventory_args')
12435 
    if self.amazonfbainventorysnapshot is not None:
12436 
      oprot.writeFieldBegin('amazonfbainventorysnapshot', TType.STRUCT, 1)
12437 
      self.amazonfbainventorysnapshot.write(oprot)
12438 
      oprot.writeFieldEnd()
12439 
    oprot.writeFieldStop()
12440 
    oprot.writeStructEnd()
12441 
 
12442 
  def validate(self):
12443 
    return
12444 
 
12445 
 
12446 
  def __repr__(self):
12447 
    L = ['%s=%r' % (key, value)
12448 
      for key, value in self.__dict__.iteritems()]
12449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12450 
 
12451 
  def __eq__(self, other):
12452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12453 
 
12454 
  def __ne__(self, other):
12455 
    return not (self == other)
12456 
 
12457 
class addOrUpdateAmazonFbaInventory_result:
12458 
 
12459 
  thrift_spec = (
12460 
  )
12461 
 
12462 
  def read(self, iprot):
12463 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12464 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12465 
      return
12466 
    iprot.readStructBegin()
12467 
    while True:
12468 
      (fname, ftype, fid) = iprot.readFieldBegin()
12469 
      if ftype == TType.STOP:
12470 
        break
12471 
      else:
12472 
        iprot.skip(ftype)
12473 
      iprot.readFieldEnd()
12474 
    iprot.readStructEnd()
12475 
 
12476 
  def write(self, oprot):
12477 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12478 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12479 
      return
12480 
    oprot.writeStructBegin('addOrUpdateAmazonFbaInventory_result')
12481 
    oprot.writeFieldStop()
12482 
    oprot.writeStructEnd()
12483 
 
12484 
  def validate(self):
12485 
    return
12486 
 
12487 
 
12488 
  def __repr__(self):
12489 
    L = ['%s=%r' % (key, value)
12490 
      for key, value in self.__dict__.iteritems()]
12491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12492 
 
12493 
  def __eq__(self, other):
12494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12495 
 
12496 
  def __ne__(self, other):
12497 
    return not (self == other)
12498 
 
8182 amar.kumar 12499 
class addUpdateHoldInventory_args:
12500 
  """
12501 
  Attributes:
12502 
   - itemId
12503 
   - warehouseId
12504 
   - holdQuantity
12505 
   - source
12506 
  """
12507 
 
12508 
  thrift_spec = (
12509 
    None, # 0
12510 
    (1, TType.I64, 'itemId', None, None, ), # 1
12511 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12512 
    (3, TType.I64, 'holdQuantity', None, None, ), # 3
12513 
    (4, TType.I64, 'source', None, None, ), # 4
12514 
  )
12515 
 
12516 
  def __init__(self, itemId=None, warehouseId=None, holdQuantity=None, source=None,):
12517 
    self.itemId = itemId
12518 
    self.warehouseId = warehouseId
12519 
    self.holdQuantity = holdQuantity
12520 
    self.source = source
12521 
 
12522 
  def read(self, iprot):
12523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12525 
      return
12526 
    iprot.readStructBegin()
12527 
    while True:
12528 
      (fname, ftype, fid) = iprot.readFieldBegin()
12529 
      if ftype == TType.STOP:
12530 
        break
12531 
      if fid == 1:
12532 
        if ftype == TType.I64:
12533 
          self.itemId = iprot.readI64();
12534 
        else:
12535 
          iprot.skip(ftype)
12536 
      elif fid == 2:
12537 
        if ftype == TType.I64:
12538 
          self.warehouseId = iprot.readI64();
12539 
        else:
12540 
          iprot.skip(ftype)
12541 
      elif fid == 3:
12542 
        if ftype == TType.I64:
12543 
          self.holdQuantity = iprot.readI64();
12544 
        else:
12545 
          iprot.skip(ftype)
12546 
      elif fid == 4:
12547 
        if ftype == TType.I64:
12548 
          self.source = iprot.readI64();
12549 
        else:
12550 
          iprot.skip(ftype)
12551 
      else:
12552 
        iprot.skip(ftype)
12553 
      iprot.readFieldEnd()
12554 
    iprot.readStructEnd()
12555 
 
12556 
  def write(self, oprot):
12557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12559 
      return
12560 
    oprot.writeStructBegin('addUpdateHoldInventory_args')
12561 
    if self.itemId is not None:
12562 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12563 
      oprot.writeI64(self.itemId)
12564 
      oprot.writeFieldEnd()
12565 
    if self.warehouseId is not None:
12566 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12567 
      oprot.writeI64(self.warehouseId)
12568 
      oprot.writeFieldEnd()
12569 
    if self.holdQuantity is not None:
12570 
      oprot.writeFieldBegin('holdQuantity', TType.I64, 3)
12571 
      oprot.writeI64(self.holdQuantity)
12572 
      oprot.writeFieldEnd()
12573 
    if self.source is not None:
12574 
      oprot.writeFieldBegin('source', TType.I64, 4)
12575 
      oprot.writeI64(self.source)
12576 
      oprot.writeFieldEnd()
12577 
    oprot.writeFieldStop()
12578 
    oprot.writeStructEnd()
12579 
 
12580 
  def validate(self):
12581 
    return
12582 
 
12583 
 
12584 
  def __repr__(self):
12585 
    L = ['%s=%r' % (key, value)
12586 
      for key, value in self.__dict__.iteritems()]
12587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12588 
 
12589 
  def __eq__(self, other):
12590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12591 
 
12592 
  def __ne__(self, other):
12593 
    return not (self == other)
12594 
 
12595 
class addUpdateHoldInventory_result:
9762 amar.kumar 12596 
  """
12597 
  Attributes:
12598 
   - cex
12599 
  """
8182 amar.kumar 12600 
 
12601 
  thrift_spec = (
9762 amar.kumar 12602 
    None, # 0
12603 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
8182 amar.kumar 12604 
  )
12605 
 
9762 amar.kumar 12606 
  def __init__(self, cex=None,):
12607 
    self.cex = cex
12608 
 
8182 amar.kumar 12609 
  def read(self, iprot):
12610 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12611 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12612 
      return
12613 
    iprot.readStructBegin()
12614 
    while True:
12615 
      (fname, ftype, fid) = iprot.readFieldBegin()
12616 
      if ftype == TType.STOP:
12617 
        break
9762 amar.kumar 12618 
      if fid == 1:
12619 
        if ftype == TType.STRUCT:
12620 
          self.cex = InventoryServiceException()
12621 
          self.cex.read(iprot)
12622 
        else:
12623 
          iprot.skip(ftype)
8182 amar.kumar 12624 
      else:
12625 
        iprot.skip(ftype)
12626 
      iprot.readFieldEnd()
12627 
    iprot.readStructEnd()
12628 
 
12629 
  def write(self, oprot):
12630 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12631 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12632 
      return
12633 
    oprot.writeStructBegin('addUpdateHoldInventory_result')
9762 amar.kumar 12634 
    if self.cex is not None:
12635 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12636 
      self.cex.write(oprot)
12637 
      oprot.writeFieldEnd()
8182 amar.kumar 12638 
    oprot.writeFieldStop()
12639 
    oprot.writeStructEnd()
12640 
 
12641 
  def validate(self):
12642 
    return
12643 
 
12644 
 
12645 
  def __repr__(self):
12646 
    L = ['%s=%r' % (key, value)
12647 
      for key, value in self.__dict__.iteritems()]
12648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12649 
 
12650 
  def __eq__(self, other):
12651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12652 
 
12653 
  def __ne__(self, other):
12654 
    return not (self == other)
8282 kshitij.so 12655 
 
12656 
class getAmazonFbaItemInventory_args:
12657 
  """
12658 
  Attributes:
12659 
   - itemId
12660 
  """
12661 
 
12662 
  thrift_spec = (
12663 
    None, # 0
12664 
    (1, TType.I64, 'itemId', None, None, ), # 1
12665 
  )
12666 
 
12667 
  def __init__(self, itemId=None,):
12668 
    self.itemId = itemId
12669 
 
12670 
  def read(self, iprot):
12671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12673 
      return
12674 
    iprot.readStructBegin()
12675 
    while True:
12676 
      (fname, ftype, fid) = iprot.readFieldBegin()
12677 
      if ftype == TType.STOP:
12678 
        break
12679 
      if fid == 1:
12680 
        if ftype == TType.I64:
12681 
          self.itemId = iprot.readI64();
12682 
        else:
12683 
          iprot.skip(ftype)
12684 
      else:
12685 
        iprot.skip(ftype)
12686 
      iprot.readFieldEnd()
12687 
    iprot.readStructEnd()
12688 
 
12689 
  def write(self, oprot):
12690 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12691 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12692 
      return
12693 
    oprot.writeStructBegin('getAmazonFbaItemInventory_args')
12694 
    if self.itemId is not None:
12695 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12696 
      oprot.writeI64(self.itemId)
12697 
      oprot.writeFieldEnd()
12698 
    oprot.writeFieldStop()
12699 
    oprot.writeStructEnd()
12700 
 
12701 
  def validate(self):
12702 
    return
12703 
 
12704 
 
12705 
  def __repr__(self):
12706 
    L = ['%s=%r' % (key, value)
12707 
      for key, value in self.__dict__.iteritems()]
12708 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12709 
 
12710 
  def __eq__(self, other):
12711 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12712 
 
12713 
  def __ne__(self, other):
12714 
    return not (self == other)
12715 
 
12716 
class getAmazonFbaItemInventory_result:
12717 
  """
12718 
  Attributes:
12719 
   - success
12720 
  """
12721 
 
12722 
  thrift_spec = (
11173 vikram.rag 12723 
    (0, TType.LIST, 'success', (TType.STRUCT,(AmazonFbaInventorySnapshot, AmazonFbaInventorySnapshot.thrift_spec)), None, ), # 0
8282 kshitij.so 12724 
  )
12725 
 
12726 
  def __init__(self, success=None,):
12727 
    self.success = success
12728 
 
12729 
  def read(self, iprot):
12730 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12731 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12732 
      return
12733 
    iprot.readStructBegin()
12734 
    while True:
12735 
      (fname, ftype, fid) = iprot.readFieldBegin()
12736 
      if ftype == TType.STOP:
12737 
        break
12738 
      if fid == 0:
11173 vikram.rag 12739 
        if ftype == TType.LIST:
12740 
          self.success = []
12741 
          (_etype247, _size244) = iprot.readListBegin()
12742 
          for _i248 in xrange(_size244):
12743 
            _elem249 = AmazonFbaInventorySnapshot()
12744 
            _elem249.read(iprot)
12745 
            self.success.append(_elem249)
12746 
          iprot.readListEnd()
8282 kshitij.so 12747 
        else:
12748 
          iprot.skip(ftype)
12749 
      else:
12750 
        iprot.skip(ftype)
12751 
      iprot.readFieldEnd()
12752 
    iprot.readStructEnd()
12753 
 
12754 
  def write(self, oprot):
12755 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12756 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12757 
      return
12758 
    oprot.writeStructBegin('getAmazonFbaItemInventory_result')
12759 
    if self.success is not None:
11173 vikram.rag 12760 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12761 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
12762 
      for iter250 in self.success:
12763 
        iter250.write(oprot)
12764 
      oprot.writeListEnd()
8282 kshitij.so 12765 
      oprot.writeFieldEnd()
12766 
    oprot.writeFieldStop()
12767 
    oprot.writeStructEnd()
12768 
 
12769 
  def validate(self):
12770 
    return
12771 
 
12772 
 
12773 
  def __repr__(self):
12774 
    L = ['%s=%r' % (key, value)
12775 
      for key, value in self.__dict__.iteritems()]
12776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12777 
 
12778 
  def __eq__(self, other):
12779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12780 
 
12781 
  def __ne__(self, other):
12782 
    return not (self == other)
12783 
 
8363 vikram.rag 12784 
class getAllAmazonFbaItemInventory_args:
8282 kshitij.so 12785 
 
12786 
  thrift_spec = (
12787 
  )
12788 
 
12789 
  def read(self, iprot):
12790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12792 
      return
12793 
    iprot.readStructBegin()
12794 
    while True:
12795 
      (fname, ftype, fid) = iprot.readFieldBegin()
12796 
      if ftype == TType.STOP:
12797 
        break
12798 
      else:
12799 
        iprot.skip(ftype)
12800 
      iprot.readFieldEnd()
12801 
    iprot.readStructEnd()
12802 
 
12803 
  def write(self, oprot):
12804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12806 
      return
8363 vikram.rag 12807 
    oprot.writeStructBegin('getAllAmazonFbaItemInventory_args')
8282 kshitij.so 12808 
    oprot.writeFieldStop()
12809 
    oprot.writeStructEnd()
12810 
 
12811 
  def validate(self):
12812 
    return
12813 
 
12814 
 
12815 
  def __repr__(self):
12816 
    L = ['%s=%r' % (key, value)
12817 
      for key, value in self.__dict__.iteritems()]
12818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12819 
 
12820 
  def __eq__(self, other):
12821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12822 
 
12823 
  def __ne__(self, other):
12824 
    return not (self == other)
12825 
 
8363 vikram.rag 12826 
class getAllAmazonFbaItemInventory_result:
8282 kshitij.so 12827 
  """
12828 
  Attributes:
12829 
   - success
12830 
  """
12831 
 
12832 
  thrift_spec = (
12833 
    (0, TType.LIST, 'success', (TType.STRUCT,(AmazonFbaInventorySnapshot, AmazonFbaInventorySnapshot.thrift_spec)), None, ), # 0
12834 
  )
12835 
 
12836 
  def __init__(self, success=None,):
12837 
    self.success = success
12838 
 
12839 
  def read(self, iprot):
12840 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12841 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12842 
      return
12843 
    iprot.readStructBegin()
12844 
    while True:
12845 
      (fname, ftype, fid) = iprot.readFieldBegin()
12846 
      if ftype == TType.STOP:
12847 
        break
12848 
      if fid == 0:
12849 
        if ftype == TType.LIST:
12850 
          self.success = []
11173 vikram.rag 12851 
          (_etype254, _size251) = iprot.readListBegin()
12852 
          for _i255 in xrange(_size251):
12853 
            _elem256 = AmazonFbaInventorySnapshot()
12854 
            _elem256.read(iprot)
12855 
            self.success.append(_elem256)
8282 kshitij.so 12856 
          iprot.readListEnd()
12857 
        else:
12858 
          iprot.skip(ftype)
12859 
      else:
12860 
        iprot.skip(ftype)
12861 
      iprot.readFieldEnd()
12862 
    iprot.readStructEnd()
12863 
 
12864 
  def write(self, oprot):
12865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12867 
      return
8363 vikram.rag 12868 
    oprot.writeStructBegin('getAllAmazonFbaItemInventory_result')
8282 kshitij.so 12869 
    if self.success is not None:
12870 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12871 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11173 vikram.rag 12872 
      for iter257 in self.success:
12873 
        iter257.write(oprot)
8282 kshitij.so 12874 
      oprot.writeListEnd()
12875 
      oprot.writeFieldEnd()
12876 
    oprot.writeFieldStop()
12877 
    oprot.writeStructEnd()
12878 
 
12879 
  def validate(self):
12880 
    return
12881 
 
12882 
 
12883 
  def __repr__(self):
12884 
    L = ['%s=%r' % (key, value)
12885 
      for key, value in self.__dict__.iteritems()]
12886 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12887 
 
12888 
  def __eq__(self, other):
12889 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12890 
 
12891 
  def __ne__(self, other):
12892 
    return not (self == other)
8363 vikram.rag 12893 
 
12894 
class getOursGoodWarehouseIdsForLocation_args:
12895 
  """
12896 
  Attributes:
12897 
   - state_id
12898 
  """
12899 
 
12900 
  thrift_spec = (
12901 
    None, # 0
12902 
    (1, TType.I64, 'state_id', None, None, ), # 1
12903 
  )
12904 
 
12905 
  def __init__(self, state_id=None,):
12906 
    self.state_id = state_id
12907 
 
12908 
  def read(self, iprot):
12909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12911 
      return
12912 
    iprot.readStructBegin()
12913 
    while True:
12914 
      (fname, ftype, fid) = iprot.readFieldBegin()
12915 
      if ftype == TType.STOP:
12916 
        break
12917 
      if fid == 1:
12918 
        if ftype == TType.I64:
12919 
          self.state_id = iprot.readI64();
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_args')
12932 
    if self.state_id is not None:
12933 
      oprot.writeFieldBegin('state_id', TType.I64, 1)
12934 
      oprot.writeI64(self.state_id)
12935 
      oprot.writeFieldEnd()
12936 
    oprot.writeFieldStop()
12937 
    oprot.writeStructEnd()
12938 
 
12939 
  def validate(self):
12940 
    return
12941 
 
12942 
 
12943 
  def __repr__(self):
12944 
    L = ['%s=%r' % (key, value)
12945 
      for key, value in self.__dict__.iteritems()]
12946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12947 
 
12948 
  def __eq__(self, other):
12949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12950 
 
12951 
  def __ne__(self, other):
12952 
    return not (self == other)
12953 
 
12954 
class getOursGoodWarehouseIdsForLocation_result:
12955 
  """
12956 
  Attributes:
12957 
   - success
12958 
  """
12959 
 
12960 
  thrift_spec = (
12961 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12962 
  )
12963 
 
12964 
  def __init__(self, success=None,):
12965 
    self.success = success
12966 
 
12967 
  def read(self, iprot):
12968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12970 
      return
12971 
    iprot.readStructBegin()
12972 
    while True:
12973 
      (fname, ftype, fid) = iprot.readFieldBegin()
12974 
      if ftype == TType.STOP:
12975 
        break
12976 
      if fid == 0:
12977 
        if ftype == TType.LIST:
12978 
          self.success = []
11173 vikram.rag 12979 
          (_etype261, _size258) = iprot.readListBegin()
12980 
          for _i262 in xrange(_size258):
12981 
            _elem263 = iprot.readI64();
12982 
            self.success.append(_elem263)
8363 vikram.rag 12983 
          iprot.readListEnd()
12984 
        else:
12985 
          iprot.skip(ftype)
12986 
      else:
12987 
        iprot.skip(ftype)
12988 
      iprot.readFieldEnd()
12989 
    iprot.readStructEnd()
12990 
 
12991 
  def write(self, oprot):
12992 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12993 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12994 
      return
12995 
    oprot.writeStructBegin('getOursGoodWarehouseIdsForLocation_result')
12996 
    if self.success is not None:
12997 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12998 
      oprot.writeListBegin(TType.I64, len(self.success))
11173 vikram.rag 12999 
      for iter264 in self.success:
13000 
        oprot.writeI64(iter264)
8363 vikram.rag 13001 
      oprot.writeListEnd()
13002 
      oprot.writeFieldEnd()
13003 
    oprot.writeFieldStop()
13004 
    oprot.writeStructEnd()
13005 
 
13006 
  def validate(self):
13007 
    return
13008 
 
13009 
 
13010 
  def __repr__(self):
13011 
    L = ['%s=%r' % (key, value)
13012 
      for key, value in self.__dict__.iteritems()]
13013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13014 
 
13015 
  def __eq__(self, other):
13016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13017 
 
13018 
  def __ne__(self, other):
13019 
    return not (self == other)
8955 vikram.rag 13020 
 
13021 
class getHoldInventoryDetailForItemForWarehouseIdExceptSource_args:
13022 
  """
13023 
  Attributes:
13024 
   - id
13025 
   - warehouse_id
13026 
   - source
13027 
  """
13028 
 
13029 
  thrift_spec = (
13030 
    None, # 0
13031 
    (1, TType.I64, 'id', None, None, ), # 1
13032 
    (2, TType.I64, 'warehouse_id', None, None, ), # 2
13033 
    (3, TType.I64, 'source', None, None, ), # 3
13034 
  )
13035 
 
13036 
  def __init__(self, id=None, warehouse_id=None, source=None,):
13037 
    self.id = id
13038 
    self.warehouse_id = warehouse_id
13039 
    self.source = source
13040 
 
13041 
  def read(self, iprot):
13042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13044 
      return
13045 
    iprot.readStructBegin()
13046 
    while True:
13047 
      (fname, ftype, fid) = iprot.readFieldBegin()
13048 
      if ftype == TType.STOP:
13049 
        break
13050 
      if fid == 1:
13051 
        if ftype == TType.I64:
13052 
          self.id = iprot.readI64();
13053 
        else:
13054 
          iprot.skip(ftype)
13055 
      elif fid == 2:
13056 
        if ftype == TType.I64:
13057 
          self.warehouse_id = iprot.readI64();
13058 
        else:
13059 
          iprot.skip(ftype)
13060 
      elif fid == 3:
13061 
        if ftype == TType.I64:
13062 
          self.source = iprot.readI64();
13063 
        else:
13064 
          iprot.skip(ftype)
13065 
      else:
13066 
        iprot.skip(ftype)
13067 
      iprot.readFieldEnd()
13068 
    iprot.readStructEnd()
13069 
 
13070 
  def write(self, oprot):
13071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13073 
      return
13074 
    oprot.writeStructBegin('getHoldInventoryDetailForItemForWarehouseIdExceptSource_args')
13075 
    if self.id is not None:
13076 
      oprot.writeFieldBegin('id', TType.I64, 1)
13077 
      oprot.writeI64(self.id)
13078 
      oprot.writeFieldEnd()
13079 
    if self.warehouse_id is not None:
13080 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 2)
13081 
      oprot.writeI64(self.warehouse_id)
13082 
      oprot.writeFieldEnd()
13083 
    if self.source is not None:
13084 
      oprot.writeFieldBegin('source', TType.I64, 3)
13085 
      oprot.writeI64(self.source)
13086 
      oprot.writeFieldEnd()
13087 
    oprot.writeFieldStop()
13088 
    oprot.writeStructEnd()
13089 
 
13090 
  def validate(self):
13091 
    return
13092 
 
13093 
 
13094 
  def __repr__(self):
13095 
    L = ['%s=%r' % (key, value)
13096 
      for key, value in self.__dict__.iteritems()]
13097 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13098 
 
13099 
  def __eq__(self, other):
13100 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13101 
 
13102 
  def __ne__(self, other):
13103 
    return not (self == other)
13104 
 
13105 
class getHoldInventoryDetailForItemForWarehouseIdExceptSource_result:
13106 
  """
13107 
  Attributes:
13108 
   - success
13109 
  """
13110 
 
13111 
  thrift_spec = (
13112 
    (0, TType.I64, 'success', None, None, ), # 0
13113 
  )
13114 
 
13115 
  def __init__(self, success=None,):
13116 
    self.success = success
13117 
 
13118 
  def read(self, iprot):
13119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13121 
      return
13122 
    iprot.readStructBegin()
13123 
    while True:
13124 
      (fname, ftype, fid) = iprot.readFieldBegin()
13125 
      if ftype == TType.STOP:
13126 
        break
13127 
      if fid == 0:
13128 
        if ftype == TType.I64:
13129 
          self.success = iprot.readI64();
13130 
        else:
13131 
          iprot.skip(ftype)
13132 
      else:
13133 
        iprot.skip(ftype)
13134 
      iprot.readFieldEnd()
13135 
    iprot.readStructEnd()
13136 
 
13137 
  def write(self, oprot):
13138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13140 
      return
13141 
    oprot.writeStructBegin('getHoldInventoryDetailForItemForWarehouseIdExceptSource_result')
13142 
    if self.success is not None:
13143 
      oprot.writeFieldBegin('success', TType.I64, 0)
13144 
      oprot.writeI64(self.success)
13145 
      oprot.writeFieldEnd()
13146 
    oprot.writeFieldStop()
13147 
    oprot.writeStructEnd()
13148 
 
13149 
  def validate(self):
13150 
    return
13151 
 
13152 
 
13153 
  def __repr__(self):
13154 
    L = ['%s=%r' % (key, value)
13155 
      for key, value in self.__dict__.iteritems()]
13156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13157 
 
13158 
  def __eq__(self, other):
13159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13160 
 
13161 
  def __ne__(self, other):
13162 
    return not (self == other)
9404 vikram.rag 13163 
 
13164 
class getSnapdealInventoryForItem_args:
13165 
  """
13166 
  Attributes:
13167 
   - item_id
13168 
  """
13169 
 
13170 
  thrift_spec = (
13171 
    None, # 0
13172 
    (1, TType.I64, 'item_id', None, None, ), # 1
13173 
  )
13174 
 
13175 
  def __init__(self, item_id=None,):
13176 
    self.item_id = item_id
13177 
 
13178 
  def read(self, iprot):
13179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13181 
      return
13182 
    iprot.readStructBegin()
13183 
    while True:
13184 
      (fname, ftype, fid) = iprot.readFieldBegin()
13185 
      if ftype == TType.STOP:
13186 
        break
13187 
      if fid == 1:
13188 
        if ftype == TType.I64:
13189 
          self.item_id = iprot.readI64();
13190 
        else:
13191 
          iprot.skip(ftype)
13192 
      else:
13193 
        iprot.skip(ftype)
13194 
      iprot.readFieldEnd()
13195 
    iprot.readStructEnd()
13196 
 
13197 
  def write(self, oprot):
13198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13200 
      return
13201 
    oprot.writeStructBegin('getSnapdealInventoryForItem_args')
13202 
    if self.item_id is not None:
13203 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
13204 
      oprot.writeI64(self.item_id)
13205 
      oprot.writeFieldEnd()
13206 
    oprot.writeFieldStop()
13207 
    oprot.writeStructEnd()
13208 
 
13209 
  def validate(self):
13210 
    return
13211 
 
13212 
 
13213 
  def __repr__(self):
13214 
    L = ['%s=%r' % (key, value)
13215 
      for key, value in self.__dict__.iteritems()]
13216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13217 
 
13218 
  def __eq__(self, other):
13219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13220 
 
13221 
  def __ne__(self, other):
13222 
    return not (self == other)
13223 
 
13224 
class getSnapdealInventoryForItem_result:
13225 
  """
13226 
  Attributes:
13227 
   - success
13228 
  """
13229 
 
13230 
  thrift_spec = (
13231 
    (0, TType.STRUCT, 'success', (SnapdealInventoryItem, SnapdealInventoryItem.thrift_spec), None, ), # 0
13232 
  )
13233 
 
13234 
  def __init__(self, success=None,):
13235 
    self.success = success
13236 
 
13237 
  def read(self, iprot):
13238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13240 
      return
13241 
    iprot.readStructBegin()
13242 
    while True:
13243 
      (fname, ftype, fid) = iprot.readFieldBegin()
13244 
      if ftype == TType.STOP:
13245 
        break
13246 
      if fid == 0:
13247 
        if ftype == TType.STRUCT:
13248 
          self.success = SnapdealInventoryItem()
13249 
          self.success.read(iprot)
13250 
        else:
13251 
          iprot.skip(ftype)
13252 
      else:
13253 
        iprot.skip(ftype)
13254 
      iprot.readFieldEnd()
13255 
    iprot.readStructEnd()
13256 
 
13257 
  def write(self, oprot):
13258 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13259 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13260 
      return
13261 
    oprot.writeStructBegin('getSnapdealInventoryForItem_result')
13262 
    if self.success is not None:
13263 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13264 
      self.success.write(oprot)
13265 
      oprot.writeFieldEnd()
13266 
    oprot.writeFieldStop()
13267 
    oprot.writeStructEnd()
13268 
 
13269 
  def validate(self):
13270 
    return
13271 
 
13272 
 
13273 
  def __repr__(self):
13274 
    L = ['%s=%r' % (key, value)
13275 
      for key, value in self.__dict__.iteritems()]
13276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13277 
 
13278 
  def __eq__(self, other):
13279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13280 
 
13281 
  def __ne__(self, other):
13282 
    return not (self == other)
13283 
 
13284 
class addOrUpdateSnapdealInventoryForItem_args:
13285 
  """
13286 
  Attributes:
13287 
   - snapdealinventoryitem
13288 
  """
13289 
 
13290 
  thrift_spec = (
13291 
    None, # 0
13292 
    (1, TType.STRUCT, 'snapdealinventoryitem', (SnapdealInventoryItem, SnapdealInventoryItem.thrift_spec), None, ), # 1
13293 
  )
13294 
 
13295 
  def __init__(self, snapdealinventoryitem=None,):
13296 
    self.snapdealinventoryitem = snapdealinventoryitem
13297 
 
13298 
  def read(self, iprot):
13299 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13300 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13301 
      return
13302 
    iprot.readStructBegin()
13303 
    while True:
13304 
      (fname, ftype, fid) = iprot.readFieldBegin()
13305 
      if ftype == TType.STOP:
13306 
        break
13307 
      if fid == 1:
13308 
        if ftype == TType.STRUCT:
13309 
          self.snapdealinventoryitem = SnapdealInventoryItem()
13310 
          self.snapdealinventoryitem.read(iprot)
13311 
        else:
13312 
          iprot.skip(ftype)
13313 
      else:
13314 
        iprot.skip(ftype)
13315 
      iprot.readFieldEnd()
13316 
    iprot.readStructEnd()
13317 
 
13318 
  def write(self, oprot):
13319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13321 
      return
13322 
    oprot.writeStructBegin('addOrUpdateSnapdealInventoryForItem_args')
13323 
    if self.snapdealinventoryitem is not None:
13324 
      oprot.writeFieldBegin('snapdealinventoryitem', TType.STRUCT, 1)
13325 
      self.snapdealinventoryitem.write(oprot)
13326 
      oprot.writeFieldEnd()
13327 
    oprot.writeFieldStop()
13328 
    oprot.writeStructEnd()
13329 
 
13330 
  def validate(self):
13331 
    return
13332 
 
13333 
 
13334 
  def __repr__(self):
13335 
    L = ['%s=%r' % (key, value)
13336 
      for key, value in self.__dict__.iteritems()]
13337 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13338 
 
13339 
  def __eq__(self, other):
13340 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13341 
 
13342 
  def __ne__(self, other):
13343 
    return not (self == other)
13344 
 
13345 
class addOrUpdateSnapdealInventoryForItem_result:
13346 
 
13347 
  thrift_spec = (
13348 
  )
13349 
 
13350 
  def read(self, iprot):
13351 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13352 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13353 
      return
13354 
    iprot.readStructBegin()
13355 
    while True:
13356 
      (fname, ftype, fid) = iprot.readFieldBegin()
13357 
      if ftype == TType.STOP:
13358 
        break
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('addOrUpdateSnapdealInventoryForItem_result')
13369 
    oprot.writeFieldStop()
13370 
    oprot.writeStructEnd()
13371 
 
13372 
  def validate(self):
13373 
    return
13374 
 
13375 
 
13376 
  def __repr__(self):
13377 
    L = ['%s=%r' % (key, value)
13378 
      for key, value in self.__dict__.iteritems()]
13379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13380 
 
13381 
  def __eq__(self, other):
13382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13383 
 
13384 
  def __ne__(self, other):
13385 
    return not (self == other)
13386 
 
13387 
class getNlcForWarehouse_args:
13388 
  """
13389 
  Attributes:
13390 
   - warehouse_id
13391 
   - item_id
13392 
  """
13393 
 
13394 
  thrift_spec = (
13395 
    None, # 0
13396 
    (1, TType.I64, 'warehouse_id', None, None, ), # 1
13397 
    (2, TType.I64, 'item_id', None, None, ), # 2
13398 
  )
13399 
 
13400 
  def __init__(self, warehouse_id=None, item_id=None,):
13401 
    self.warehouse_id = warehouse_id
13402 
    self.item_id = item_id
13403 
 
13404 
  def read(self, iprot):
13405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13407 
      return
13408 
    iprot.readStructBegin()
13409 
    while True:
13410 
      (fname, ftype, fid) = iprot.readFieldBegin()
13411 
      if ftype == TType.STOP:
13412 
        break
13413 
      if fid == 1:
13414 
        if ftype == TType.I64:
13415 
          self.warehouse_id = iprot.readI64();
13416 
        else:
13417 
          iprot.skip(ftype)
13418 
      elif fid == 2:
13419 
        if ftype == TType.I64:
13420 
          self.item_id = iprot.readI64();
13421 
        else:
13422 
          iprot.skip(ftype)
13423 
      else:
13424 
        iprot.skip(ftype)
13425 
      iprot.readFieldEnd()
13426 
    iprot.readStructEnd()
13427 
 
13428 
  def write(self, oprot):
13429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13431 
      return
13432 
    oprot.writeStructBegin('getNlcForWarehouse_args')
13433 
    if self.warehouse_id is not None:
13434 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 1)
13435 
      oprot.writeI64(self.warehouse_id)
13436 
      oprot.writeFieldEnd()
13437 
    if self.item_id is not None:
13438 
      oprot.writeFieldBegin('item_id', TType.I64, 2)
13439 
      oprot.writeI64(self.item_id)
13440 
      oprot.writeFieldEnd()
13441 
    oprot.writeFieldStop()
13442 
    oprot.writeStructEnd()
13443 
 
13444 
  def validate(self):
13445 
    return
13446 
 
13447 
 
13448 
  def __repr__(self):
13449 
    L = ['%s=%r' % (key, value)
13450 
      for key, value in self.__dict__.iteritems()]
13451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13452 
 
13453 
  def __eq__(self, other):
13454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13455 
 
13456 
  def __ne__(self, other):
13457 
    return not (self == other)
13458 
 
13459 
class getNlcForWarehouse_result:
13460 
  """
13461 
  Attributes:
13462 
   - success
13463 
  """
13464 
 
13465 
  thrift_spec = (
13466 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
13467 
  )
13468 
 
13469 
  def __init__(self, success=None,):
13470 
    self.success = success
13471 
 
13472 
  def read(self, iprot):
13473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13475 
      return
13476 
    iprot.readStructBegin()
13477 
    while True:
13478 
      (fname, ftype, fid) = iprot.readFieldBegin()
13479 
      if ftype == TType.STOP:
13480 
        break
13481 
      if fid == 0:
13482 
        if ftype == TType.DOUBLE:
13483 
          self.success = iprot.readDouble();
13484 
        else:
13485 
          iprot.skip(ftype)
13486 
      else:
13487 
        iprot.skip(ftype)
13488 
      iprot.readFieldEnd()
13489 
    iprot.readStructEnd()
13490 
 
13491 
  def write(self, oprot):
13492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13494 
      return
13495 
    oprot.writeStructBegin('getNlcForWarehouse_result')
13496 
    if self.success is not None:
13497 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
13498 
      oprot.writeDouble(self.success)
13499 
      oprot.writeFieldEnd()
13500 
    oprot.writeFieldStop()
13501 
    oprot.writeStructEnd()
13502 
 
13503 
  def validate(self):
13504 
    return
13505 
 
13506 
 
13507 
  def __repr__(self):
13508 
    L = ['%s=%r' % (key, value)
13509 
      for key, value in self.__dict__.iteritems()]
13510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13511 
 
13512 
  def __eq__(self, other):
13513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13514 
 
13515 
  def __ne__(self, other):
13516 
    return not (self == other)
9456 vikram.rag 13517 
 
9640 amar.kumar 13518 
class getHeldInventoryMapForItem_args:
13519 
  """
13520 
  Attributes:
13521 
   - item_id
13522 
   - warehouse_id
13523 
  """
13524 
 
13525 
  thrift_spec = (
13526 
    None, # 0
13527 
    (1, TType.I64, 'item_id', None, None, ), # 1
13528 
    (2, TType.I64, 'warehouse_id', None, None, ), # 2
13529 
  )
13530 
 
13531 
  def __init__(self, item_id=None, warehouse_id=None,):
13532 
    self.item_id = item_id
13533 
    self.warehouse_id = warehouse_id
13534 
 
13535 
  def read(self, iprot):
13536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13538 
      return
13539 
    iprot.readStructBegin()
13540 
    while True:
13541 
      (fname, ftype, fid) = iprot.readFieldBegin()
13542 
      if ftype == TType.STOP:
13543 
        break
13544 
      if fid == 1:
13545 
        if ftype == TType.I64:
13546 
          self.item_id = iprot.readI64();
13547 
        else:
13548 
          iprot.skip(ftype)
13549 
      elif fid == 2:
13550 
        if ftype == TType.I64:
13551 
          self.warehouse_id = iprot.readI64();
13552 
        else:
13553 
          iprot.skip(ftype)
13554 
      else:
13555 
        iprot.skip(ftype)
13556 
      iprot.readFieldEnd()
13557 
    iprot.readStructEnd()
13558 
 
13559 
  def write(self, oprot):
13560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13562 
      return
13563 
    oprot.writeStructBegin('getHeldInventoryMapForItem_args')
13564 
    if self.item_id is not None:
13565 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
13566 
      oprot.writeI64(self.item_id)
13567 
      oprot.writeFieldEnd()
13568 
    if self.warehouse_id is not None:
13569 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 2)
13570 
      oprot.writeI64(self.warehouse_id)
13571 
      oprot.writeFieldEnd()
13572 
    oprot.writeFieldStop()
13573 
    oprot.writeStructEnd()
13574 
 
13575 
  def validate(self):
13576 
    return
13577 
 
13578 
 
13579 
  def __repr__(self):
13580 
    L = ['%s=%r' % (key, value)
13581 
      for key, value in self.__dict__.iteritems()]
13582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13583 
 
13584 
  def __eq__(self, other):
13585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13586 
 
13587 
  def __ne__(self, other):
13588 
    return not (self == other)
13589 
 
13590 
class getHeldInventoryMapForItem_result:
13591 
  """
13592 
  Attributes:
13593 
   - success
13594 
  """
13595 
 
13596 
  thrift_spec = (
13597 
    (0, TType.MAP, 'success', (TType.I32,None,TType.I64,None), None, ), # 0
13598 
  )
13599 
 
13600 
  def __init__(self, success=None,):
13601 
    self.success = success
13602 
 
13603 
  def read(self, iprot):
13604 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13605 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13606 
      return
13607 
    iprot.readStructBegin()
13608 
    while True:
13609 
      (fname, ftype, fid) = iprot.readFieldBegin()
13610 
      if ftype == TType.STOP:
13611 
        break
13612 
      if fid == 0:
13613 
        if ftype == TType.MAP:
13614 
          self.success = {}
11173 vikram.rag 13615 
          (_ktype266, _vtype267, _size265 ) = iprot.readMapBegin()
13616 
          for _i269 in xrange(_size265):
13617 
            _key270 = iprot.readI32();
13618 
            _val271 = iprot.readI64();
13619 
            self.success[_key270] = _val271
9640 amar.kumar 13620 
          iprot.readMapEnd()
13621 
        else:
13622 
          iprot.skip(ftype)
13623 
      else:
13624 
        iprot.skip(ftype)
13625 
      iprot.readFieldEnd()
13626 
    iprot.readStructEnd()
13627 
 
13628 
  def write(self, oprot):
13629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13631 
      return
13632 
    oprot.writeStructBegin('getHeldInventoryMapForItem_result')
13633 
    if self.success is not None:
13634 
      oprot.writeFieldBegin('success', TType.MAP, 0)
13635 
      oprot.writeMapBegin(TType.I32, TType.I64, len(self.success))
11173 vikram.rag 13636 
      for kiter272,viter273 in self.success.items():
13637 
        oprot.writeI32(kiter272)
13638 
        oprot.writeI64(viter273)
9640 amar.kumar 13639 
      oprot.writeMapEnd()
13640 
      oprot.writeFieldEnd()
13641 
    oprot.writeFieldStop()
13642 
    oprot.writeStructEnd()
13643 
 
13644 
  def validate(self):
13645 
    return
13646 
 
13647 
 
13648 
  def __repr__(self):
13649 
    L = ['%s=%r' % (key, value)
13650 
      for key, value in self.__dict__.iteritems()]
13651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13652 
 
13653 
  def __eq__(self, other):
13654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13655 
 
13656 
  def __ne__(self, other):
13657 
    return not (self == other)
13658 
 
9495 vikram.rag 13659 
class addOrUpdateAllAmazonFbaInventory_args:
13660 
  """
13661 
  Attributes:
13662 
   - allamazonfbainventorysnapshot
13663 
  """
9456 vikram.rag 13664 
 
9495 vikram.rag 13665 
  thrift_spec = None
13666 
  def __init__(self, allamazonfbainventorysnapshot=None,):
13667 
    self.allamazonfbainventorysnapshot = allamazonfbainventorysnapshot
9456 vikram.rag 13668 
 
13669 
  def read(self, iprot):
13670 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13671 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13672 
      return
13673 
    iprot.readStructBegin()
13674 
    while True:
13675 
      (fname, ftype, fid) = iprot.readFieldBegin()
13676 
      if ftype == TType.STOP:
13677 
        break
9495 vikram.rag 13678 
      if fid == -1:
13679 
        if ftype == TType.LIST:
13680 
          self.allamazonfbainventorysnapshot = []
11173 vikram.rag 13681 
          (_etype277, _size274) = iprot.readListBegin()
13682 
          for _i278 in xrange(_size274):
13683 
            _elem279 = AmazonFbaInventorySnapshot()
13684 
            _elem279.read(iprot)
13685 
            self.allamazonfbainventorysnapshot.append(_elem279)
9495 vikram.rag 13686 
          iprot.readListEnd()
13687 
        else:
13688 
          iprot.skip(ftype)
9456 vikram.rag 13689 
      else:
13690 
        iprot.skip(ftype)
13691 
      iprot.readFieldEnd()
13692 
    iprot.readStructEnd()
13693 
 
13694 
  def write(self, oprot):
13695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13697 
      return
9495 vikram.rag 13698 
    oprot.writeStructBegin('addOrUpdateAllAmazonFbaInventory_args')
13699 
    if self.allamazonfbainventorysnapshot is not None:
13700 
      oprot.writeFieldBegin('allamazonfbainventorysnapshot', TType.LIST, -1)
13701 
      oprot.writeListBegin(TType.STRUCT, len(self.allamazonfbainventorysnapshot))
11173 vikram.rag 13702 
      for iter280 in self.allamazonfbainventorysnapshot:
13703 
        iter280.write(oprot)
9495 vikram.rag 13704 
      oprot.writeListEnd()
13705 
      oprot.writeFieldEnd()
9456 vikram.rag 13706 
    oprot.writeFieldStop()
13707 
    oprot.writeStructEnd()
13708 
 
13709 
  def validate(self):
13710 
    return
13711 
 
13712 
 
13713 
  def __repr__(self):
13714 
    L = ['%s=%r' % (key, value)
13715 
      for key, value in self.__dict__.iteritems()]
13716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13717 
 
13718 
  def __eq__(self, other):
13719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13720 
 
13721 
  def __ne__(self, other):
13722 
    return not (self == other)
13723 
 
9495 vikram.rag 13724 
class addOrUpdateAllAmazonFbaInventory_result:
9456 vikram.rag 13725 
 
13726 
  thrift_spec = (
13727 
  )
13728 
 
13729 
  def read(self, iprot):
13730 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13731 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13732 
      return
13733 
    iprot.readStructBegin()
13734 
    while True:
13735 
      (fname, ftype, fid) = iprot.readFieldBegin()
13736 
      if ftype == TType.STOP:
13737 
        break
13738 
      else:
13739 
        iprot.skip(ftype)
13740 
      iprot.readFieldEnd()
13741 
    iprot.readStructEnd()
13742 
 
13743 
  def write(self, oprot):
13744 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13745 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13746 
      return
9495 vikram.rag 13747 
    oprot.writeStructBegin('addOrUpdateAllAmazonFbaInventory_result')
9456 vikram.rag 13748 
    oprot.writeFieldStop()
13749 
    oprot.writeStructEnd()
13750 
 
13751 
  def validate(self):
13752 
    return
13753 
 
13754 
 
13755 
  def __repr__(self):
13756 
    L = ['%s=%r' % (key, value)
13757 
      for key, value in self.__dict__.iteritems()]
13758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13759 
 
13760 
  def __eq__(self, other):
13761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13762 
 
13763 
  def __ne__(self, other):
13764 
    return not (self == other)
9482 vikram.rag 13765 
 
9495 vikram.rag 13766 
class addOrUpdateAllSnapdealInventory_args:
9482 vikram.rag 13767 
  """
13768 
  Attributes:
9495 vikram.rag 13769 
   - allsnapdealinventorysnapshot
9482 vikram.rag 13770 
  """
13771 
 
13772 
  thrift_spec = None
9495 vikram.rag 13773 
  def __init__(self, allsnapdealinventorysnapshot=None,):
13774 
    self.allsnapdealinventorysnapshot = allsnapdealinventorysnapshot
9482 vikram.rag 13775 
 
13776 
  def read(self, iprot):
13777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13779 
      return
13780 
    iprot.readStructBegin()
13781 
    while True:
13782 
      (fname, ftype, fid) = iprot.readFieldBegin()
13783 
      if ftype == TType.STOP:
13784 
        break
13785 
      if fid == -1:
13786 
        if ftype == TType.LIST:
9495 vikram.rag 13787 
          self.allsnapdealinventorysnapshot = []
11173 vikram.rag 13788 
          (_etype284, _size281) = iprot.readListBegin()
13789 
          for _i285 in xrange(_size281):
13790 
            _elem286 = SnapdealInventoryItem()
13791 
            _elem286.read(iprot)
13792 
            self.allsnapdealinventorysnapshot.append(_elem286)
9482 vikram.rag 13793 
          iprot.readListEnd()
13794 
        else:
13795 
          iprot.skip(ftype)
13796 
      else:
13797 
        iprot.skip(ftype)
13798 
      iprot.readFieldEnd()
13799 
    iprot.readStructEnd()
13800 
 
13801 
  def write(self, oprot):
13802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13804 
      return
9495 vikram.rag 13805 
    oprot.writeStructBegin('addOrUpdateAllSnapdealInventory_args')
13806 
    if self.allsnapdealinventorysnapshot is not None:
13807 
      oprot.writeFieldBegin('allsnapdealinventorysnapshot', TType.LIST, -1)
13808 
      oprot.writeListBegin(TType.STRUCT, len(self.allsnapdealinventorysnapshot))
11173 vikram.rag 13809 
      for iter287 in self.allsnapdealinventorysnapshot:
13810 
        iter287.write(oprot)
9482 vikram.rag 13811 
      oprot.writeListEnd()
13812 
      oprot.writeFieldEnd()
13813 
    oprot.writeFieldStop()
13814 
    oprot.writeStructEnd()
13815 
 
13816 
  def validate(self):
13817 
    return
13818 
 
13819 
 
13820 
  def __repr__(self):
13821 
    L = ['%s=%r' % (key, value)
13822 
      for key, value in self.__dict__.iteritems()]
13823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13824 
 
13825 
  def __eq__(self, other):
13826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13827 
 
13828 
  def __ne__(self, other):
13829 
    return not (self == other)
13830 
 
9495 vikram.rag 13831 
class addOrUpdateAllSnapdealInventory_result:
9482 vikram.rag 13832 
 
13833 
  thrift_spec = (
13834 
  )
13835 
 
13836 
  def read(self, iprot):
13837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13839 
      return
13840 
    iprot.readStructBegin()
13841 
    while True:
13842 
      (fname, ftype, fid) = iprot.readFieldBegin()
13843 
      if ftype == TType.STOP:
13844 
        break
13845 
      else:
13846 
        iprot.skip(ftype)
13847 
      iprot.readFieldEnd()
13848 
    iprot.readStructEnd()
13849 
 
13850 
  def write(self, oprot):
13851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13853 
      return
9495 vikram.rag 13854 
    oprot.writeStructBegin('addOrUpdateAllSnapdealInventory_result')
9482 vikram.rag 13855 
    oprot.writeFieldStop()
13856 
    oprot.writeStructEnd()
13857 
 
13858 
  def validate(self):
13859 
    return
13860 
 
13861 
 
13862 
  def __repr__(self):
13863 
    L = ['%s=%r' % (key, value)
13864 
      for key, value in self.__dict__.iteritems()]
13865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13866 
 
13867 
  def __eq__(self, other):
13868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13869 
 
13870 
  def __ne__(self, other):
13871 
    return not (self == other)
9495 vikram.rag 13872 
 
13873 
class getSnapdealInventorySnapshot_args:
13874 
 
13875 
  thrift_spec = (
13876 
  )
13877 
 
13878 
  def read(self, iprot):
13879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13881 
      return
13882 
    iprot.readStructBegin()
13883 
    while True:
13884 
      (fname, ftype, fid) = iprot.readFieldBegin()
13885 
      if ftype == TType.STOP:
13886 
        break
13887 
      else:
13888 
        iprot.skip(ftype)
13889 
      iprot.readFieldEnd()
13890 
    iprot.readStructEnd()
13891 
 
13892 
  def write(self, oprot):
13893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13895 
      return
13896 
    oprot.writeStructBegin('getSnapdealInventorySnapshot_args')
13897 
    oprot.writeFieldStop()
13898 
    oprot.writeStructEnd()
13899 
 
13900 
  def validate(self):
13901 
    return
13902 
 
13903 
 
13904 
  def __repr__(self):
13905 
    L = ['%s=%r' % (key, value)
13906 
      for key, value in self.__dict__.iteritems()]
13907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13908 
 
13909 
  def __eq__(self, other):
13910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13911 
 
13912 
  def __ne__(self, other):
13913 
    return not (self == other)
13914 
 
13915 
class getSnapdealInventorySnapshot_result:
13916 
  """
13917 
  Attributes:
13918 
   - success
13919 
  """
13920 
 
13921 
  thrift_spec = (
13922 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealInventoryItem, SnapdealInventoryItem.thrift_spec)), None, ), # 0
13923 
  )
13924 
 
13925 
  def __init__(self, success=None,):
13926 
    self.success = success
13927 
 
13928 
  def read(self, iprot):
13929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13931 
      return
13932 
    iprot.readStructBegin()
13933 
    while True:
13934 
      (fname, ftype, fid) = iprot.readFieldBegin()
13935 
      if ftype == TType.STOP:
13936 
        break
13937 
      if fid == 0:
13938 
        if ftype == TType.LIST:
13939 
          self.success = []
11173 vikram.rag 13940 
          (_etype291, _size288) = iprot.readListBegin()
13941 
          for _i292 in xrange(_size288):
13942 
            _elem293 = SnapdealInventoryItem()
13943 
            _elem293.read(iprot)
13944 
            self.success.append(_elem293)
9495 vikram.rag 13945 
          iprot.readListEnd()
13946 
        else:
13947 
          iprot.skip(ftype)
13948 
      else:
13949 
        iprot.skip(ftype)
13950 
      iprot.readFieldEnd()
13951 
    iprot.readStructEnd()
13952 
 
13953 
  def write(self, oprot):
13954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13956 
      return
13957 
    oprot.writeStructBegin('getSnapdealInventorySnapshot_result')
13958 
    if self.success is not None:
13959 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13960 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11173 vikram.rag 13961 
      for iter294 in self.success:
13962 
        iter294.write(oprot)
9495 vikram.rag 13963 
      oprot.writeListEnd()
13964 
      oprot.writeFieldEnd()
13965 
    oprot.writeFieldStop()
13966 
    oprot.writeStructEnd()
13967 
 
13968 
  def validate(self):
13969 
    return
13970 
 
13971 
 
13972 
  def __repr__(self):
13973 
    L = ['%s=%r' % (key, value)
13974 
      for key, value in self.__dict__.iteritems()]
13975 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13976 
 
13977 
  def __eq__(self, other):
13978 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13979 
 
13980 
  def __ne__(self, other):
13981 
    return not (self == other)
9761 amar.kumar 13982 
 
13983 
class getHoldInventoryDetails_args:
13984 
  """
13985 
  Attributes:
13986 
   - itemId
13987 
   - warehouseId
13988 
   - source
13989 
  """
13990 
 
13991 
  thrift_spec = (
13992 
    None, # 0
13993 
    (1, TType.I64, 'itemId', None, None, ), # 1
13994 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
13995 
    (3, TType.I64, 'source', None, None, ), # 3
13996 
  )
13997 
 
13998 
  def __init__(self, itemId=None, warehouseId=None, source=None,):
13999 
    self.itemId = itemId
14000 
    self.warehouseId = warehouseId
14001 
    self.source = source
14002 
 
14003 
  def read(self, iprot):
14004 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14005 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14006 
      return
14007 
    iprot.readStructBegin()
14008 
    while True:
14009 
      (fname, ftype, fid) = iprot.readFieldBegin()
14010 
      if ftype == TType.STOP:
14011 
        break
14012 
      if fid == 1:
14013 
        if ftype == TType.I64:
14014 
          self.itemId = iprot.readI64();
14015 
        else:
14016 
          iprot.skip(ftype)
14017 
      elif fid == 2:
14018 
        if ftype == TType.I64:
14019 
          self.warehouseId = iprot.readI64();
14020 
        else:
14021 
          iprot.skip(ftype)
14022 
      elif fid == 3:
14023 
        if ftype == TType.I64:
14024 
          self.source = iprot.readI64();
14025 
        else:
14026 
          iprot.skip(ftype)
14027 
      else:
14028 
        iprot.skip(ftype)
14029 
      iprot.readFieldEnd()
14030 
    iprot.readStructEnd()
14031 
 
14032 
  def write(self, oprot):
14033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14035 
      return
14036 
    oprot.writeStructBegin('getHoldInventoryDetails_args')
14037 
    if self.itemId is not None:
14038 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14039 
      oprot.writeI64(self.itemId)
14040 
      oprot.writeFieldEnd()
14041 
    if self.warehouseId is not None:
14042 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
14043 
      oprot.writeI64(self.warehouseId)
14044 
      oprot.writeFieldEnd()
14045 
    if self.source is not None:
14046 
      oprot.writeFieldBegin('source', TType.I64, 3)
14047 
      oprot.writeI64(self.source)
14048 
      oprot.writeFieldEnd()
14049 
    oprot.writeFieldStop()
14050 
    oprot.writeStructEnd()
14051 
 
14052 
  def validate(self):
14053 
    return
14054 
 
14055 
 
14056 
  def __repr__(self):
14057 
    L = ['%s=%r' % (key, value)
14058 
      for key, value in self.__dict__.iteritems()]
14059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14060 
 
14061 
  def __eq__(self, other):
14062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14063 
 
14064 
  def __ne__(self, other):
14065 
    return not (self == other)
14066 
 
14067 
class getHoldInventoryDetails_result:
14068 
  """
14069 
  Attributes:
14070 
   - success
14071 
  """
14072 
 
14073 
  thrift_spec = (
14074 
    (0, TType.LIST, 'success', (TType.STRUCT,(HoldInventoryDetail, HoldInventoryDetail.thrift_spec)), None, ), # 0
14075 
  )
14076 
 
14077 
  def __init__(self, success=None,):
14078 
    self.success = success
14079 
 
14080 
  def read(self, iprot):
14081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14083 
      return
14084 
    iprot.readStructBegin()
14085 
    while True:
14086 
      (fname, ftype, fid) = iprot.readFieldBegin()
14087 
      if ftype == TType.STOP:
14088 
        break
14089 
      if fid == 0:
14090 
        if ftype == TType.LIST:
14091 
          self.success = []
11173 vikram.rag 14092 
          (_etype298, _size295) = iprot.readListBegin()
14093 
          for _i299 in xrange(_size295):
14094 
            _elem300 = HoldInventoryDetail()
14095 
            _elem300.read(iprot)
14096 
            self.success.append(_elem300)
9761 amar.kumar 14097 
          iprot.readListEnd()
14098 
        else:
14099 
          iprot.skip(ftype)
14100 
      else:
14101 
        iprot.skip(ftype)
14102 
      iprot.readFieldEnd()
14103 
    iprot.readStructEnd()
14104 
 
14105 
  def write(self, oprot):
14106 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14107 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14108 
      return
14109 
    oprot.writeStructBegin('getHoldInventoryDetails_result')
14110 
    if self.success is not None:
14111 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14112 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11173 vikram.rag 14113 
      for iter301 in self.success:
14114 
        iter301.write(oprot)
9761 amar.kumar 14115 
      oprot.writeListEnd()
14116 
      oprot.writeFieldEnd()
14117 
    oprot.writeFieldStop()
14118 
    oprot.writeStructEnd()
14119 
 
14120 
  def validate(self):
14121 
    return
14122 
 
14123 
 
14124 
  def __repr__(self):
14125 
    L = ['%s=%r' % (key, value)
14126 
      for key, value in self.__dict__.iteritems()]
14127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14128 
 
14129 
  def __eq__(self, other):
14130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14131 
 
14132 
  def __ne__(self, other):
14133 
    return not (self == other)
10050 vikram.rag 14134 
 
14135 
class addOrUpdateFlipkartInventorySnapshot_args:
14136 
  """
14137 
  Attributes:
14138 
   - flipkartInventorySnapshot
10450 vikram.rag 14139 
   - time
10050 vikram.rag 14140 
  """
14141 
 
10450 vikram.rag 14142 
  thrift_spec = (
14143 
    None, # 0
14144 
    (1, TType.LIST, 'flipkartInventorySnapshot', (TType.STRUCT,(FlipkartInventorySnapshot, FlipkartInventorySnapshot.thrift_spec)), None, ), # 1
14145 
    (2, TType.I64, 'time', None, None, ), # 2
14146 
  )
14147 
 
14148 
  def __init__(self, flipkartInventorySnapshot=None, time=None,):
10050 vikram.rag 14149 
    self.flipkartInventorySnapshot = flipkartInventorySnapshot
10450 vikram.rag 14150 
    self.time = time
10050 vikram.rag 14151 
 
14152 
  def read(self, iprot):
14153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14155 
      return
14156 
    iprot.readStructBegin()
14157 
    while True:
14158 
      (fname, ftype, fid) = iprot.readFieldBegin()
14159 
      if ftype == TType.STOP:
14160 
        break
10450 vikram.rag 14161 
      if fid == 1:
10050 vikram.rag 14162 
        if ftype == TType.LIST:
14163 
          self.flipkartInventorySnapshot = []
11173 vikram.rag 14164 
          (_etype305, _size302) = iprot.readListBegin()
14165 
          for _i306 in xrange(_size302):
14166 
            _elem307 = FlipkartInventorySnapshot()
14167 
            _elem307.read(iprot)
14168 
            self.flipkartInventorySnapshot.append(_elem307)
10050 vikram.rag 14169 
          iprot.readListEnd()
14170 
        else:
14171 
          iprot.skip(ftype)
10450 vikram.rag 14172 
      elif fid == 2:
14173 
        if ftype == TType.I64:
14174 
          self.time = iprot.readI64();
14175 
        else:
14176 
          iprot.skip(ftype)
10050 vikram.rag 14177 
      else:
14178 
        iprot.skip(ftype)
14179 
      iprot.readFieldEnd()
14180 
    iprot.readStructEnd()
14181 
 
14182 
  def write(self, oprot):
14183 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14184 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14185 
      return
14186 
    oprot.writeStructBegin('addOrUpdateFlipkartInventorySnapshot_args')
14187 
    if self.flipkartInventorySnapshot is not None:
10450 vikram.rag 14188 
      oprot.writeFieldBegin('flipkartInventorySnapshot', TType.LIST, 1)
10050 vikram.rag 14189 
      oprot.writeListBegin(TType.STRUCT, len(self.flipkartInventorySnapshot))
11173 vikram.rag 14190 
      for iter308 in self.flipkartInventorySnapshot:
14191 
        iter308.write(oprot)
10050 vikram.rag 14192 
      oprot.writeListEnd()
14193 
      oprot.writeFieldEnd()
10450 vikram.rag 14194 
    if self.time is not None:
14195 
      oprot.writeFieldBegin('time', TType.I64, 2)
14196 
      oprot.writeI64(self.time)
14197 
      oprot.writeFieldEnd()
10050 vikram.rag 14198 
    oprot.writeFieldStop()
14199 
    oprot.writeStructEnd()
14200 
 
14201 
  def validate(self):
14202 
    return
14203 
 
14204 
 
14205 
  def __repr__(self):
14206 
    L = ['%s=%r' % (key, value)
14207 
      for key, value in self.__dict__.iteritems()]
14208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14209 
 
14210 
  def __eq__(self, other):
14211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14212 
 
14213 
  def __ne__(self, other):
14214 
    return not (self == other)
14215 
 
14216 
class addOrUpdateFlipkartInventorySnapshot_result:
14217 
 
14218 
  thrift_spec = (
14219 
  )
14220 
 
14221 
  def read(self, iprot):
14222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14224 
      return
14225 
    iprot.readStructBegin()
14226 
    while True:
14227 
      (fname, ftype, fid) = iprot.readFieldBegin()
14228 
      if ftype == TType.STOP:
14229 
        break
14230 
      else:
14231 
        iprot.skip(ftype)
14232 
      iprot.readFieldEnd()
14233 
    iprot.readStructEnd()
14234 
 
14235 
  def write(self, oprot):
14236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14238 
      return
14239 
    oprot.writeStructBegin('addOrUpdateFlipkartInventorySnapshot_result')
14240 
    oprot.writeFieldStop()
14241 
    oprot.writeStructEnd()
14242 
 
14243 
  def validate(self):
14244 
    return
14245 
 
14246 
 
14247 
  def __repr__(self):
14248 
    L = ['%s=%r' % (key, value)
14249 
      for key, value in self.__dict__.iteritems()]
14250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14251 
 
14252 
  def __eq__(self, other):
14253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14254 
 
14255 
  def __ne__(self, other):
14256 
    return not (self == other)
14257 
 
14258 
class getFlipkartInventorySnapshot_args:
14259 
 
14260 
  thrift_spec = (
14261 
  )
14262 
 
14263 
  def read(self, iprot):
14264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14266 
      return
14267 
    iprot.readStructBegin()
14268 
    while True:
14269 
      (fname, ftype, fid) = iprot.readFieldBegin()
14270 
      if ftype == TType.STOP:
14271 
        break
14272 
      else:
14273 
        iprot.skip(ftype)
14274 
      iprot.readFieldEnd()
14275 
    iprot.readStructEnd()
14276 
 
14277 
  def write(self, oprot):
14278 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14279 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14280 
      return
14281 
    oprot.writeStructBegin('getFlipkartInventorySnapshot_args')
14282 
    oprot.writeFieldStop()
14283 
    oprot.writeStructEnd()
14284 
 
14285 
  def validate(self):
14286 
    return
14287 
 
14288 
 
14289 
  def __repr__(self):
14290 
    L = ['%s=%r' % (key, value)
14291 
      for key, value in self.__dict__.iteritems()]
14292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14293 
 
14294 
  def __eq__(self, other):
14295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14296 
 
14297 
  def __ne__(self, other):
14298 
    return not (self == other)
14299 
 
14300 
class getFlipkartInventorySnapshot_result:
14301 
  """
14302 
  Attributes:
14303 
   - success
14304 
  """
14305 
 
14306 
  thrift_spec = (
14307 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartInventorySnapshot, FlipkartInventorySnapshot.thrift_spec)), None, ), # 0
14308 
  )
14309 
 
14310 
  def __init__(self, success=None,):
14311 
    self.success = success
14312 
 
14313 
  def read(self, iprot):
14314 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14315 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14316 
      return
14317 
    iprot.readStructBegin()
14318 
    while True:
14319 
      (fname, ftype, fid) = iprot.readFieldBegin()
14320 
      if ftype == TType.STOP:
14321 
        break
14322 
      if fid == 0:
14323 
        if ftype == TType.LIST:
14324 
          self.success = []
11173 vikram.rag 14325 
          (_etype312, _size309) = iprot.readListBegin()
14326 
          for _i313 in xrange(_size309):
14327 
            _elem314 = FlipkartInventorySnapshot()
14328 
            _elem314.read(iprot)
14329 
            self.success.append(_elem314)
10050 vikram.rag 14330 
          iprot.readListEnd()
14331 
        else:
14332 
          iprot.skip(ftype)
14333 
      else:
14334 
        iprot.skip(ftype)
14335 
      iprot.readFieldEnd()
14336 
    iprot.readStructEnd()
14337 
 
14338 
  def write(self, oprot):
14339 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14340 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14341 
      return
14342 
    oprot.writeStructBegin('getFlipkartInventorySnapshot_result')
14343 
    if self.success is not None:
14344 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14345 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11173 vikram.rag 14346 
      for iter315 in self.success:
14347 
        iter315.write(oprot)
10050 vikram.rag 14348 
      oprot.writeListEnd()
14349 
      oprot.writeFieldEnd()
14350 
    oprot.writeFieldStop()
14351 
    oprot.writeStructEnd()
14352 
 
14353 
  def validate(self):
14354 
    return
14355 
 
14356 
 
14357 
  def __repr__(self):
14358 
    L = ['%s=%r' % (key, value)
14359 
      for key, value in self.__dict__.iteritems()]
14360 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14361 
 
14362 
  def __eq__(self, other):
14363 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14364 
 
14365 
  def __ne__(self, other):
14366 
    return not (self == other)
10097 kshitij.so 14367 
 
14368 
class getFlipkartlInventoryForItem_args:
14369 
  """
14370 
  Attributes:
14371 
   - item_id
14372 
  """
14373 
 
14374 
  thrift_spec = (
14375 
    None, # 0
14376 
    (1, TType.I64, 'item_id', None, None, ), # 1
14377 
  )
14378 
 
14379 
  def __init__(self, item_id=None,):
14380 
    self.item_id = item_id
14381 
 
14382 
  def read(self, iprot):
14383 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14384 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14385 
      return
14386 
    iprot.readStructBegin()
14387 
    while True:
14388 
      (fname, ftype, fid) = iprot.readFieldBegin()
14389 
      if ftype == TType.STOP:
14390 
        break
14391 
      if fid == 1:
14392 
        if ftype == TType.I64:
14393 
          self.item_id = iprot.readI64();
14394 
        else:
14395 
          iprot.skip(ftype)
14396 
      else:
14397 
        iprot.skip(ftype)
14398 
      iprot.readFieldEnd()
14399 
    iprot.readStructEnd()
14400 
 
14401 
  def write(self, oprot):
14402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14404 
      return
14405 
    oprot.writeStructBegin('getFlipkartlInventoryForItem_args')
14406 
    if self.item_id is not None:
14407 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
14408 
      oprot.writeI64(self.item_id)
14409 
      oprot.writeFieldEnd()
14410 
    oprot.writeFieldStop()
14411 
    oprot.writeStructEnd()
14412 
 
14413 
  def validate(self):
14414 
    return
14415 
 
14416 
 
14417 
  def __repr__(self):
14418 
    L = ['%s=%r' % (key, value)
14419 
      for key, value in self.__dict__.iteritems()]
14420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14421 
 
14422 
  def __eq__(self, other):
14423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14424 
 
14425 
  def __ne__(self, other):
14426 
    return not (self == other)
14427 
 
14428 
class getFlipkartlInventoryForItem_result:
14429 
  """
14430 
  Attributes:
14431 
   - success
14432 
  """
14433 
 
14434 
  thrift_spec = (
14435 
    (0, TType.STRUCT, 'success', (FlipkartInventorySnapshot, FlipkartInventorySnapshot.thrift_spec), None, ), # 0
14436 
  )
14437 
 
14438 
  def __init__(self, success=None,):
14439 
    self.success = success
14440 
 
14441 
  def read(self, iprot):
14442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14444 
      return
14445 
    iprot.readStructBegin()
14446 
    while True:
14447 
      (fname, ftype, fid) = iprot.readFieldBegin()
14448 
      if ftype == TType.STOP:
14449 
        break
14450 
      if fid == 0:
14451 
        if ftype == TType.STRUCT:
14452 
          self.success = FlipkartInventorySnapshot()
14453 
          self.success.read(iprot)
14454 
        else:
14455 
          iprot.skip(ftype)
14456 
      else:
14457 
        iprot.skip(ftype)
14458 
      iprot.readFieldEnd()
14459 
    iprot.readStructEnd()
14460 
 
14461 
  def write(self, oprot):
14462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14464 
      return
14465 
    oprot.writeStructBegin('getFlipkartlInventoryForItem_result')
14466 
    if self.success is not None:
14467 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14468 
      self.success.write(oprot)
14469 
      oprot.writeFieldEnd()
14470 
    oprot.writeFieldStop()
14471 
    oprot.writeStructEnd()
14472 
 
14473 
  def validate(self):
14474 
    return
14475 
 
14476 
 
14477 
  def __repr__(self):
14478 
    L = ['%s=%r' % (key, value)
14479 
      for key, value in self.__dict__.iteritems()]
14480 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14481 
 
14482 
  def __eq__(self, other):
14483 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14484 
 
14485 
  def __ne__(self, other):
14486 
    return not (self == other)
10485 vikram.rag 14487 
 
14488 
class getStateMaster_args:
14489 
 
14490 
  thrift_spec = (
14491 
  )
14492 
 
14493 
  def read(self, iprot):
14494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14496 
      return
14497 
    iprot.readStructBegin()
14498 
    while True:
14499 
      (fname, ftype, fid) = iprot.readFieldBegin()
14500 
      if ftype == TType.STOP:
14501 
        break
14502 
      else:
14503 
        iprot.skip(ftype)
14504 
      iprot.readFieldEnd()
14505 
    iprot.readStructEnd()
14506 
 
14507 
  def write(self, oprot):
14508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14510 
      return
14511 
    oprot.writeStructBegin('getStateMaster_args')
14512 
    oprot.writeFieldStop()
14513 
    oprot.writeStructEnd()
14514 
 
14515 
  def validate(self):
14516 
    return
14517 
 
14518 
 
14519 
  def __repr__(self):
14520 
    L = ['%s=%r' % (key, value)
14521 
      for key, value in self.__dict__.iteritems()]
14522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14523 
 
14524 
  def __eq__(self, other):
14525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14526 
 
14527 
  def __ne__(self, other):
14528 
    return not (self == other)
14529 
 
14530 
class getStateMaster_result:
14531 
  """
14532 
  Attributes:
14533 
   - success
14534 
  """
14535 
 
14536 
  thrift_spec = (
12280 amit.gupta 14537 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRUCT,(StateInfo, StateInfo.thrift_spec)), None, ), # 0
10485 vikram.rag 14538 
  )
14539 
 
14540 
  def __init__(self, success=None,):
14541 
    self.success = success
14542 
 
14543 
  def read(self, iprot):
14544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14546 
      return
14547 
    iprot.readStructBegin()
14548 
    while True:
14549 
      (fname, ftype, fid) = iprot.readFieldBegin()
14550 
      if ftype == TType.STOP:
14551 
        break
14552 
      if fid == 0:
14553 
        if ftype == TType.MAP:
14554 
          self.success = {}
11173 vikram.rag 14555 
          (_ktype317, _vtype318, _size316 ) = iprot.readMapBegin()
14556 
          for _i320 in xrange(_size316):
14557 
            _key321 = iprot.readI64();
12280 amit.gupta 14558 
            _val322 = StateInfo()
14559 
            _val322.read(iprot)
11173 vikram.rag 14560 
            self.success[_key321] = _val322
10485 vikram.rag 14561 
          iprot.readMapEnd()
14562 
        else:
14563 
          iprot.skip(ftype)
14564 
      else:
14565 
        iprot.skip(ftype)
14566 
      iprot.readFieldEnd()
14567 
    iprot.readStructEnd()
14568 
 
14569 
  def write(self, oprot):
14570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14572 
      return
14573 
    oprot.writeStructBegin('getStateMaster_result')
14574 
    if self.success is not None:
14575 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12280 amit.gupta 14576 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.success))
11173 vikram.rag 14577 
      for kiter323,viter324 in self.success.items():
14578 
        oprot.writeI64(kiter323)
12280 amit.gupta 14579 
        viter324.write(oprot)
10485 vikram.rag 14580 
      oprot.writeMapEnd()
14581 
      oprot.writeFieldEnd()
14582 
    oprot.writeFieldStop()
14583 
    oprot.writeStructEnd()
14584 
 
14585 
  def validate(self):
14586 
    return
14587 
 
14588 
 
14589 
  def __repr__(self):
14590 
    L = ['%s=%r' % (key, value)
14591 
      for key, value in self.__dict__.iteritems()]
14592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14593 
 
14594 
  def __eq__(self, other):
14595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14596 
 
14597 
  def __ne__(self, other):
14598 
    return not (self == other)
10544 vikram.rag 14599 
 
14600 
class updateSnapdealStockAtEOD_args:
14601 
  """
14602 
  Attributes:
14603 
   - allsnapdealstock
14604 
  """
14605 
 
14606 
  thrift_spec = None
14607 
  def __init__(self, allsnapdealstock=None,):
14608 
    self.allsnapdealstock = allsnapdealstock
14609 
 
14610 
  def read(self, iprot):
14611 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14612 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14613 
      return
14614 
    iprot.readStructBegin()
14615 
    while True:
14616 
      (fname, ftype, fid) = iprot.readFieldBegin()
14617 
      if ftype == TType.STOP:
14618 
        break
14619 
      if fid == -1:
14620 
        if ftype == TType.LIST:
14621 
          self.allsnapdealstock = []
11173 vikram.rag 14622 
          (_etype328, _size325) = iprot.readListBegin()
14623 
          for _i329 in xrange(_size325):
14624 
            _elem330 = SnapdealStockAtEOD()
14625 
            _elem330.read(iprot)
14626 
            self.allsnapdealstock.append(_elem330)
10544 vikram.rag 14627 
          iprot.readListEnd()
14628 
        else:
14629 
          iprot.skip(ftype)
14630 
      else:
14631 
        iprot.skip(ftype)
14632 
      iprot.readFieldEnd()
14633 
    iprot.readStructEnd()
14634 
 
14635 
  def write(self, oprot):
14636 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14637 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14638 
      return
14639 
    oprot.writeStructBegin('updateSnapdealStockAtEOD_args')
14640 
    if self.allsnapdealstock is not None:
14641 
      oprot.writeFieldBegin('allsnapdealstock', TType.LIST, -1)
14642 
      oprot.writeListBegin(TType.STRUCT, len(self.allsnapdealstock))
11173 vikram.rag 14643 
      for iter331 in self.allsnapdealstock:
14644 
        iter331.write(oprot)
10544 vikram.rag 14645 
      oprot.writeListEnd()
14646 
      oprot.writeFieldEnd()
14647 
    oprot.writeFieldStop()
14648 
    oprot.writeStructEnd()
14649 
 
14650 
  def validate(self):
14651 
    return
14652 
 
14653 
 
14654 
  def __repr__(self):
14655 
    L = ['%s=%r' % (key, value)
14656 
      for key, value in self.__dict__.iteritems()]
14657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14658 
 
14659 
  def __eq__(self, other):
14660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14661 
 
14662 
  def __ne__(self, other):
14663 
    return not (self == other)
14664 
 
14665 
class updateSnapdealStockAtEOD_result:
14666 
 
14667 
  thrift_spec = (
14668 
  )
14669 
 
14670 
  def read(self, iprot):
14671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14673 
      return
14674 
    iprot.readStructBegin()
14675 
    while True:
14676 
      (fname, ftype, fid) = iprot.readFieldBegin()
14677 
      if ftype == TType.STOP:
14678 
        break
14679 
      else:
14680 
        iprot.skip(ftype)
14681 
      iprot.readFieldEnd()
14682 
    iprot.readStructEnd()
14683 
 
14684 
  def write(self, oprot):
14685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14687 
      return
14688 
    oprot.writeStructBegin('updateSnapdealStockAtEOD_result')
14689 
    oprot.writeFieldStop()
14690 
    oprot.writeStructEnd()
14691 
 
14692 
  def validate(self):
14693 
    return
14694 
 
14695 
 
14696 
  def __repr__(self):
14697 
    L = ['%s=%r' % (key, value)
14698 
      for key, value in self.__dict__.iteritems()]
14699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14700 
 
14701 
  def __eq__(self, other):
14702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14703 
 
14704 
  def __ne__(self, other):
14705 
    return not (self == other)
14706 
 
14707 
class updateFlipkartStockAtEOD_args:
14708 
  """
14709 
  Attributes:
14710 
   - allflipkartstock
14711 
  """
14712 
 
14713 
  thrift_spec = None
14714 
  def __init__(self, allflipkartstock=None,):
14715 
    self.allflipkartstock = allflipkartstock
14716 
 
14717 
  def read(self, iprot):
14718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14720 
      return
14721 
    iprot.readStructBegin()
14722 
    while True:
14723 
      (fname, ftype, fid) = iprot.readFieldBegin()
14724 
      if ftype == TType.STOP:
14725 
        break
14726 
      if fid == -1:
14727 
        if ftype == TType.LIST:
14728 
          self.allflipkartstock = []
11173 vikram.rag 14729 
          (_etype335, _size332) = iprot.readListBegin()
14730 
          for _i336 in xrange(_size332):
14731 
            _elem337 = FlipkartStockAtEOD()
14732 
            _elem337.read(iprot)
14733 
            self.allflipkartstock.append(_elem337)
10544 vikram.rag 14734 
          iprot.readListEnd()
14735 
        else:
14736 
          iprot.skip(ftype)
14737 
      else:
14738 
        iprot.skip(ftype)
14739 
      iprot.readFieldEnd()
14740 
    iprot.readStructEnd()
14741 
 
14742 
  def write(self, oprot):
14743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14745 
      return
14746 
    oprot.writeStructBegin('updateFlipkartStockAtEOD_args')
14747 
    if self.allflipkartstock is not None:
14748 
      oprot.writeFieldBegin('allflipkartstock', TType.LIST, -1)
14749 
      oprot.writeListBegin(TType.STRUCT, len(self.allflipkartstock))
11173 vikram.rag 14750 
      for iter338 in self.allflipkartstock:
14751 
        iter338.write(oprot)
10544 vikram.rag 14752 
      oprot.writeListEnd()
14753 
      oprot.writeFieldEnd()
14754 
    oprot.writeFieldStop()
14755 
    oprot.writeStructEnd()
14756 
 
14757 
  def validate(self):
14758 
    return
14759 
 
14760 
 
14761 
  def __repr__(self):
14762 
    L = ['%s=%r' % (key, value)
14763 
      for key, value in self.__dict__.iteritems()]
14764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14765 
 
14766 
  def __eq__(self, other):
14767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14768 
 
14769 
  def __ne__(self, other):
14770 
    return not (self == other)
14771 
 
14772 
class updateFlipkartStockAtEOD_result:
14773 
 
14774 
  thrift_spec = (
14775 
  )
14776 
 
14777 
  def read(self, iprot):
14778 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14779 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14780 
      return
14781 
    iprot.readStructBegin()
14782 
    while True:
14783 
      (fname, ftype, fid) = iprot.readFieldBegin()
14784 
      if ftype == TType.STOP:
14785 
        break
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('updateFlipkartStockAtEOD_result')
14796 
    oprot.writeFieldStop()
14797 
    oprot.writeStructEnd()
14798 
 
14799 
  def validate(self):
14800 
    return
14801 
 
14802 
 
14803 
  def __repr__(self):
14804 
    L = ['%s=%r' % (key, value)
14805 
      for key, value in self.__dict__.iteritems()]
14806 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14807 
 
14808 
  def __eq__(self, other):
14809 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14810 
 
14811 
  def __ne__(self, other):
14812 
    return not (self == other)
12363 kshitij.so 14813 
 
14814 
class getWanNlcForSource_args:
14815 
  """
14816 
  Attributes:
14817 
   - item_id
14818 
   - source
14819 
  """
14820 
 
14821 
  thrift_spec = (
14822 
    None, # 0
14823 
    (1, TType.I64, 'item_id', None, None, ), # 1
14824 
    (2, TType.I64, 'source', None, None, ), # 2
14825 
  )
14826 
 
14827 
  def __init__(self, item_id=None, source=None,):
14828 
    self.item_id = item_id
14829 
    self.source = source
14830 
 
14831 
  def read(self, iprot):
14832 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14833 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14834 
      return
14835 
    iprot.readStructBegin()
14836 
    while True:
14837 
      (fname, ftype, fid) = iprot.readFieldBegin()
14838 
      if ftype == TType.STOP:
14839 
        break
14840 
      if fid == 1:
14841 
        if ftype == TType.I64:
14842 
          self.item_id = iprot.readI64();
14843 
        else:
14844 
          iprot.skip(ftype)
14845 
      elif fid == 2:
14846 
        if ftype == TType.I64:
14847 
          self.source = iprot.readI64();
14848 
        else:
14849 
          iprot.skip(ftype)
14850 
      else:
14851 
        iprot.skip(ftype)
14852 
      iprot.readFieldEnd()
14853 
    iprot.readStructEnd()
14854 
 
14855 
  def write(self, oprot):
14856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14858 
      return
14859 
    oprot.writeStructBegin('getWanNlcForSource_args')
14860 
    if self.item_id is not None:
14861 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
14862 
      oprot.writeI64(self.item_id)
14863 
      oprot.writeFieldEnd()
14864 
    if self.source is not None:
14865 
      oprot.writeFieldBegin('source', TType.I64, 2)
14866 
      oprot.writeI64(self.source)
14867 
      oprot.writeFieldEnd()
14868 
    oprot.writeFieldStop()
14869 
    oprot.writeStructEnd()
14870 
 
14871 
  def validate(self):
14872 
    return
14873 
 
14874 
 
14875 
  def __repr__(self):
14876 
    L = ['%s=%r' % (key, value)
14877 
      for key, value in self.__dict__.iteritems()]
14878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14879 
 
14880 
  def __eq__(self, other):
14881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14882 
 
14883 
  def __ne__(self, other):
14884 
    return not (self == other)
14885 
 
14886 
class getWanNlcForSource_result:
14887 
  """
14888 
  Attributes:
14889 
   - success
14890 
  """
14891 
 
14892 
  thrift_spec = (
14893 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
14894 
  )
14895 
 
14896 
  def __init__(self, success=None,):
14897 
    self.success = success
14898 
 
14899 
  def read(self, iprot):
14900 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14901 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14902 
      return
14903 
    iprot.readStructBegin()
14904 
    while True:
14905 
      (fname, ftype, fid) = iprot.readFieldBegin()
14906 
      if ftype == TType.STOP:
14907 
        break
14908 
      if fid == 0:
14909 
        if ftype == TType.DOUBLE:
14910 
          self.success = iprot.readDouble();
14911 
        else:
14912 
          iprot.skip(ftype)
14913 
      else:
14914 
        iprot.skip(ftype)
14915 
      iprot.readFieldEnd()
14916 
    iprot.readStructEnd()
14917 
 
14918 
  def write(self, oprot):
14919 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14920 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14921 
      return
14922 
    oprot.writeStructBegin('getWanNlcForSource_result')
14923 
    if self.success is not None:
14924 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
14925 
      oprot.writeDouble(self.success)
14926 
      oprot.writeFieldEnd()
14927 
    oprot.writeFieldStop()
14928 
    oprot.writeStructEnd()
14929 
 
14930 
  def validate(self):
14931 
    return
14932 
 
14933 
 
14934 
  def __repr__(self):
14935 
    L = ['%s=%r' % (key, value)
14936 
      for key, value in self.__dict__.iteritems()]
14937 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14938 
 
14939 
  def __eq__(self, other):
14940 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14941 
 
14942 
  def __ne__(self, other):
14943 
    return not (self == other)
14944 
 
14945 
class getAllAvailableAmazonFbaItemInventory_args:
14946 
 
14947 
  thrift_spec = (
14948 
  )
14949 
 
14950 
  def read(self, iprot):
14951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14953 
      return
14954 
    iprot.readStructBegin()
14955 
    while True:
14956 
      (fname, ftype, fid) = iprot.readFieldBegin()
14957 
      if ftype == TType.STOP:
14958 
        break
14959 
      else:
14960 
        iprot.skip(ftype)
14961 
      iprot.readFieldEnd()
14962 
    iprot.readStructEnd()
14963 
 
14964 
  def write(self, oprot):
14965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14967 
      return
14968 
    oprot.writeStructBegin('getAllAvailableAmazonFbaItemInventory_args')
14969 
    oprot.writeFieldStop()
14970 
    oprot.writeStructEnd()
14971 
 
14972 
  def validate(self):
14973 
    return
14974 
 
14975 
 
14976 
  def __repr__(self):
14977 
    L = ['%s=%r' % (key, value)
14978 
      for key, value in self.__dict__.iteritems()]
14979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14980 
 
14981 
  def __eq__(self, other):
14982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14983 
 
14984 
  def __ne__(self, other):
14985 
    return not (self == other)
14986 
 
14987 
class getAllAvailableAmazonFbaItemInventory_result:
14988 
  """
14989 
  Attributes:
14990 
   - success
14991 
  """
14992 
 
14993 
  thrift_spec = (
14994 
    (0, TType.LIST, 'success', (TType.STRUCT,(AmazonFbaInventorySnapshot, AmazonFbaInventorySnapshot.thrift_spec)), None, ), # 0
14995 
  )
14996 
 
14997 
  def __init__(self, success=None,):
14998 
    self.success = success
14999 
 
15000 
  def read(self, iprot):
15001 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15002 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15003 
      return
15004 
    iprot.readStructBegin()
15005 
    while True:
15006 
      (fname, ftype, fid) = iprot.readFieldBegin()
15007 
      if ftype == TType.STOP:
15008 
        break
15009 
      if fid == 0:
15010 
        if ftype == TType.LIST:
15011 
          self.success = []
15012 
          (_etype342, _size339) = iprot.readListBegin()
15013 
          for _i343 in xrange(_size339):
15014 
            _elem344 = AmazonFbaInventorySnapshot()
15015 
            _elem344.read(iprot)
15016 
            self.success.append(_elem344)
15017 
          iprot.readListEnd()
15018 
        else:
15019 
          iprot.skip(ftype)
15020 
      else:
15021 
        iprot.skip(ftype)
15022 
      iprot.readFieldEnd()
15023 
    iprot.readStructEnd()
15024 
 
15025 
  def write(self, oprot):
15026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15028 
      return
15029 
    oprot.writeStructBegin('getAllAvailableAmazonFbaItemInventory_result')
15030 
    if self.success is not None:
15031 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15032 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
15033 
      for iter345 in self.success:
15034 
        iter345.write(oprot)
15035 
      oprot.writeListEnd()
15036 
      oprot.writeFieldEnd()
15037 
    oprot.writeFieldStop()
15038 
    oprot.writeStructEnd()
15039 
 
15040 
  def validate(self):
15041 
    return
15042 
 
15043 
 
15044 
  def __repr__(self):
15045 
    L = ['%s=%r' % (key, value)
15046 
      for key, value in self.__dict__.iteritems()]
15047 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15048 
 
15049 
  def __eq__(self, other):
15050 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15051 
 
15052 
  def __ne__(self, other):
15053 
    return not (self == other)
17990 kshitij.so 15054 
 
15055 
class updateItemAvailabilityForItemIds_args:
15056 
  """
15057 
  Attributes:
15058 
   - itemIds
15059 
  """
15060 
 
15061 
  thrift_spec = (
15062 
    None, # 0
15063 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
15064 
  )
15065 
 
15066 
  def __init__(self, itemIds=None,):
15067 
    self.itemIds = itemIds
15068 
 
15069 
  def read(self, iprot):
15070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15072 
      return
15073 
    iprot.readStructBegin()
15074 
    while True:
15075 
      (fname, ftype, fid) = iprot.readFieldBegin()
15076 
      if ftype == TType.STOP:
15077 
        break
15078 
      if fid == 1:
15079 
        if ftype == TType.LIST:
15080 
          self.itemIds = []
15081 
          (_etype349, _size346) = iprot.readListBegin()
15082 
          for _i350 in xrange(_size346):
15083 
            _elem351 = iprot.readI64();
15084 
            self.itemIds.append(_elem351)
15085 
          iprot.readListEnd()
15086 
        else:
15087 
          iprot.skip(ftype)
15088 
      else:
15089 
        iprot.skip(ftype)
15090 
      iprot.readFieldEnd()
15091 
    iprot.readStructEnd()
15092 
 
15093 
  def write(self, oprot):
15094 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15095 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15096 
      return
15097 
    oprot.writeStructBegin('updateItemAvailabilityForItemIds_args')
15098 
    if self.itemIds is not None:
15099 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
15100 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
15101 
      for iter352 in self.itemIds:
15102 
        oprot.writeI64(iter352)
15103 
      oprot.writeListEnd()
15104 
      oprot.writeFieldEnd()
15105 
    oprot.writeFieldStop()
15106 
    oprot.writeStructEnd()
15107 
 
15108 
  def validate(self):
15109 
    return
15110 
 
15111 
 
15112 
  def __repr__(self):
15113 
    L = ['%s=%r' % (key, value)
15114 
      for key, value in self.__dict__.iteritems()]
15115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15116 
 
15117 
  def __eq__(self, other):
15118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15119 
 
15120 
  def __ne__(self, other):
15121 
    return not (self == other)
15122 
 
15123 
class updateItemAvailabilityForItemIds_result:
15124 
  """
15125 
  Attributes:
15126 
   - success
15127 
  """
15128 
 
15129 
  thrift_spec = (
15130 
    (0, TType.BOOL, 'success', None, None, ), # 0
15131 
  )
15132 
 
15133 
  def __init__(self, success=None,):
15134 
    self.success = success
15135 
 
15136 
  def read(self, iprot):
15137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15139 
      return
15140 
    iprot.readStructBegin()
15141 
    while True:
15142 
      (fname, ftype, fid) = iprot.readFieldBegin()
15143 
      if ftype == TType.STOP:
15144 
        break
15145 
      if fid == 0:
15146 
        if ftype == TType.BOOL:
15147 
          self.success = iprot.readBool();
15148 
        else:
15149 
          iprot.skip(ftype)
15150 
      else:
15151 
        iprot.skip(ftype)
15152 
      iprot.readFieldEnd()
15153 
    iprot.readStructEnd()
15154 
 
15155 
  def write(self, oprot):
15156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15158 
      return
15159 
    oprot.writeStructBegin('updateItemAvailabilityForItemIds_result')
15160 
    if self.success is not None:
15161 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15162 
      oprot.writeBool(self.success)
15163 
      oprot.writeFieldEnd()
15164 
    oprot.writeFieldStop()
15165 
    oprot.writeStructEnd()
15166 
 
15167 
  def validate(self):
15168 
    return
15169 
 
15170 
 
15171 
  def __repr__(self):
15172 
    L = ['%s=%r' % (key, value)
15173 
      for key, value in self.__dict__.iteritems()]
15174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15175 
 
15176 
  def __eq__(self, other):
15177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15178 
 
15179 
  def __ne__(self, other):
15180 
    return not (self == other)
19247 kshitij.so 15181 
 
15182 
class addVendorItemPricingInBulk_args:
15183 
  """
15184 
  Attributes:
15185 
   - vendorItemPricingList
15186 
  """
15187 
 
15188 
  thrift_spec = (
15189 
    None, # 0
15190 
    (1, TType.LIST, 'vendorItemPricingList', (TType.STRUCT,(VendorItemPricing, VendorItemPricing.thrift_spec)), None, ), # 1
15191 
  )
15192 
 
15193 
  def __init__(self, vendorItemPricingList=None,):
15194 
    self.vendorItemPricingList = vendorItemPricingList
15195 
 
15196 
  def read(self, iprot):
15197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15199 
      return
15200 
    iprot.readStructBegin()
15201 
    while True:
15202 
      (fname, ftype, fid) = iprot.readFieldBegin()
15203 
      if ftype == TType.STOP:
15204 
        break
15205 
      if fid == 1:
15206 
        if ftype == TType.LIST:
15207 
          self.vendorItemPricingList = []
15208 
          (_etype356, _size353) = iprot.readListBegin()
15209 
          for _i357 in xrange(_size353):
15210 
            _elem358 = VendorItemPricing()
15211 
            _elem358.read(iprot)
15212 
            self.vendorItemPricingList.append(_elem358)
15213 
          iprot.readListEnd()
15214 
        else:
15215 
          iprot.skip(ftype)
15216 
      else:
15217 
        iprot.skip(ftype)
15218 
      iprot.readFieldEnd()
15219 
    iprot.readStructEnd()
15220 
 
15221 
  def write(self, oprot):
15222 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15223 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15224 
      return
15225 
    oprot.writeStructBegin('addVendorItemPricingInBulk_args')
15226 
    if self.vendorItemPricingList is not None:
15227 
      oprot.writeFieldBegin('vendorItemPricingList', TType.LIST, 1)
15228 
      oprot.writeListBegin(TType.STRUCT, len(self.vendorItemPricingList))
15229 
      for iter359 in self.vendorItemPricingList:
15230 
        iter359.write(oprot)
15231 
      oprot.writeListEnd()
15232 
      oprot.writeFieldEnd()
15233 
    oprot.writeFieldStop()
15234 
    oprot.writeStructEnd()
15235 
 
15236 
  def validate(self):
15237 
    return
15238 
 
15239 
 
15240 
  def __repr__(self):
15241 
    L = ['%s=%r' % (key, value)
15242 
      for key, value in self.__dict__.iteritems()]
15243 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15244 
 
15245 
  def __eq__(self, other):
15246 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15247 
 
15248 
  def __ne__(self, other):
15249 
    return not (self == other)
15250 
 
15251 
class addVendorItemPricingInBulk_result:
15252 
  """
15253 
  Attributes:
15254 
   - success
15255 
  """
15256 
 
15257 
  thrift_spec = (
15258 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
15259 
  )
15260 
 
15261 
  def __init__(self, success=None,):
15262 
    self.success = success
15263 
 
15264 
  def read(self, iprot):
15265 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15266 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15267 
      return
15268 
    iprot.readStructBegin()
15269 
    while True:
15270 
      (fname, ftype, fid) = iprot.readFieldBegin()
15271 
      if ftype == TType.STOP:
15272 
        break
15273 
      if fid == 0:
15274 
        if ftype == TType.LIST:
15275 
          self.success = []
15276 
          (_etype363, _size360) = iprot.readListBegin()
15277 
          for _i364 in xrange(_size360):
15278 
            _elem365 = iprot.readI64();
15279 
            self.success.append(_elem365)
15280 
          iprot.readListEnd()
15281 
        else:
15282 
          iprot.skip(ftype)
15283 
      else:
15284 
        iprot.skip(ftype)
15285 
      iprot.readFieldEnd()
15286 
    iprot.readStructEnd()
15287 
 
15288 
  def write(self, oprot):
15289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15291 
      return
15292 
    oprot.writeStructBegin('addVendorItemPricingInBulk_result')
15293 
    if self.success is not None:
15294 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15295 
      oprot.writeListBegin(TType.I64, len(self.success))
15296 
      for iter366 in self.success:
15297 
        oprot.writeI64(iter366)
15298 
      oprot.writeListEnd()
15299 
      oprot.writeFieldEnd()
15300 
    oprot.writeFieldStop()
15301 
    oprot.writeStructEnd()
15302 
 
15303 
  def validate(self):
15304 
    return
15305 
 
15306 
 
15307 
  def __repr__(self):
15308 
    L = ['%s=%r' % (key, value)
15309 
      for key, value in self.__dict__.iteritems()]
15310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15311 
 
15312 
  def __eq__(self, other):
15313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15314 
 
15315 
  def __ne__(self, other):
15316 
    return not (self == other)
15317 
 
15318 
class addInventoryInBulk_args:
15319 
  """
15320 
  Attributes:
15321 
   - bulkInventoryList
15322 
  """
15323 
 
15324 
  thrift_spec = (
15325 
    None, # 0
15326 
    (1, TType.LIST, 'bulkInventoryList', (TType.STRUCT,(BulkAddInventory, BulkAddInventory.thrift_spec)), None, ), # 1
15327 
  )
15328 
 
15329 
  def __init__(self, bulkInventoryList=None,):
15330 
    self.bulkInventoryList = bulkInventoryList
15331 
 
15332 
  def read(self, iprot):
15333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15335 
      return
15336 
    iprot.readStructBegin()
15337 
    while True:
15338 
      (fname, ftype, fid) = iprot.readFieldBegin()
15339 
      if ftype == TType.STOP:
15340 
        break
15341 
      if fid == 1:
15342 
        if ftype == TType.LIST:
15343 
          self.bulkInventoryList = []
15344 
          (_etype370, _size367) = iprot.readListBegin()
15345 
          for _i371 in xrange(_size367):
15346 
            _elem372 = BulkAddInventory()
15347 
            _elem372.read(iprot)
15348 
            self.bulkInventoryList.append(_elem372)
15349 
          iprot.readListEnd()
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_args')
15362 
    if self.bulkInventoryList is not None:
15363 
      oprot.writeFieldBegin('bulkInventoryList', TType.LIST, 1)
15364 
      oprot.writeListBegin(TType.STRUCT, len(self.bulkInventoryList))
15365 
      for iter373 in self.bulkInventoryList:
15366 
        iter373.write(oprot)
15367 
      oprot.writeListEnd()
15368 
      oprot.writeFieldEnd()
15369 
    oprot.writeFieldStop()
15370 
    oprot.writeStructEnd()
15371 
 
15372 
  def validate(self):
15373 
    return
15374 
 
15375 
 
15376 
  def __repr__(self):
15377 
    L = ['%s=%r' % (key, value)
15378 
      for key, value in self.__dict__.iteritems()]
15379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15380 
 
15381 
  def __eq__(self, other):
15382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15383 
 
15384 
  def __ne__(self, other):
15385 
    return not (self == other)
15386 
 
15387 
class addInventoryInBulk_result:
15388 
  """
15389 
  Attributes:
15390 
   - cex
15391 
  """
15392 
 
15393 
  thrift_spec = (
15394 
    None, # 0
15395 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
15396 
  )
15397 
 
15398 
  def __init__(self, cex=None,):
15399 
    self.cex = cex
15400 
 
15401 
  def read(self, iprot):
15402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15404 
      return
15405 
    iprot.readStructBegin()
15406 
    while True:
15407 
      (fname, ftype, fid) = iprot.readFieldBegin()
15408 
      if ftype == TType.STOP:
15409 
        break
15410 
      if fid == 1:
15411 
        if ftype == TType.STRUCT:
15412 
          self.cex = InventoryServiceException()
15413 
          self.cex.read(iprot)
15414 
        else:
15415 
          iprot.skip(ftype)
15416 
      else:
15417 
        iprot.skip(ftype)
15418 
      iprot.readFieldEnd()
15419 
    iprot.readStructEnd()
15420 
 
15421 
  def write(self, oprot):
15422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15424 
      return
15425 
    oprot.writeStructBegin('addInventoryInBulk_result')
15426 
    if self.cex is not None:
15427 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15428 
      self.cex.write(oprot)
15429 
      oprot.writeFieldEnd()
15430 
    oprot.writeFieldStop()
15431 
    oprot.writeStructEnd()
15432 
 
15433 
  def validate(self):
15434 
    return
15435 
 
15436 
 
15437 
  def __repr__(self):
15438 
    L = ['%s=%r' % (key, value)
15439 
      for key, value in self.__dict__.iteritems()]
15440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15441 
 
15442 
  def __eq__(self, other):
15443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15444 
 
15445 
  def __ne__(self, other):
15446 
    return not (self == other)
19413 amit.gupta 15447 
 
22717 amit.gupta 15448 
class getFofoAvailability_args:
15449 
  """
15450 
  Attributes:
15451 
   - itemIds
15452 
  """
15453 
 
15454 
  thrift_spec = (
15455 
    None, # 0
15456 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
15457 
  )
15458 
 
15459 
  def __init__(self, itemIds=None,):
15460 
    self.itemIds = itemIds
15461 
 
15462 
  def read(self, iprot):
15463 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15464 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15465 
      return
15466 
    iprot.readStructBegin()
15467 
    while True:
15468 
      (fname, ftype, fid) = iprot.readFieldBegin()
15469 
      if ftype == TType.STOP:
15470 
        break
15471 
      if fid == 1:
15472 
        if ftype == TType.LIST:
15473 
          self.itemIds = []
15474 
          (_etype377, _size374) = iprot.readListBegin()
15475 
          for _i378 in xrange(_size374):
15476 
            _elem379 = iprot.readI64();
15477 
            self.itemIds.append(_elem379)
15478 
          iprot.readListEnd()
15479 
        else:
15480 
          iprot.skip(ftype)
15481 
      else:
15482 
        iprot.skip(ftype)
15483 
      iprot.readFieldEnd()
15484 
    iprot.readStructEnd()
15485 
 
15486 
  def write(self, oprot):
15487 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15488 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15489 
      return
15490 
    oprot.writeStructBegin('getFofoAvailability_args')
15491 
    if self.itemIds is not None:
15492 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
15493 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
15494 
      for iter380 in self.itemIds:
15495 
        oprot.writeI64(iter380)
15496 
      oprot.writeListEnd()
15497 
      oprot.writeFieldEnd()
15498 
    oprot.writeFieldStop()
15499 
    oprot.writeStructEnd()
15500 
 
15501 
  def validate(self):
15502 
    return
15503 
 
15504 
 
15505 
  def __repr__(self):
15506 
    L = ['%s=%r' % (key, value)
15507 
      for key, value in self.__dict__.iteritems()]
15508 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15509 
 
15510 
  def __eq__(self, other):
15511 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15512 
 
15513 
  def __ne__(self, other):
15514 
    return not (self == other)
15515 
 
15516 
class getFofoAvailability_result:
15517 
  """
15518 
  Attributes:
15519 
   - success
15520 
  """
15521 
 
15522 
  thrift_spec = (
15523 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
15524 
  )
15525 
 
15526 
  def __init__(self, success=None,):
15527 
    self.success = success
15528 
 
15529 
  def read(self, iprot):
15530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15532 
      return
15533 
    iprot.readStructBegin()
15534 
    while True:
15535 
      (fname, ftype, fid) = iprot.readFieldBegin()
15536 
      if ftype == TType.STOP:
15537 
        break
15538 
      if fid == 0:
15539 
        if ftype == TType.MAP:
15540 
          self.success = {}
15541 
          (_ktype382, _vtype383, _size381 ) = iprot.readMapBegin()
15542 
          for _i385 in xrange(_size381):
15543 
            _key386 = iprot.readI64();
15544 
            _val387 = iprot.readI64();
15545 
            self.success[_key386] = _val387
15546 
          iprot.readMapEnd()
15547 
        else:
15548 
          iprot.skip(ftype)
15549 
      else:
15550 
        iprot.skip(ftype)
15551 
      iprot.readFieldEnd()
15552 
    iprot.readStructEnd()
15553 
 
15554 
  def write(self, oprot):
15555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15557 
      return
15558 
    oprot.writeStructBegin('getFofoAvailability_result')
15559 
    if self.success is not None:
15560 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15561 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
15562 
      for kiter388,viter389 in self.success.items():
15563 
        oprot.writeI64(kiter388)
15564 
        oprot.writeI64(viter389)
15565 
      oprot.writeMapEnd()
15566 
      oprot.writeFieldEnd()
15567 
    oprot.writeFieldStop()
15568 
    oprot.writeStructEnd()
15569 
 
15570 
  def validate(self):
15571 
    return
15572 
 
15573 
 
15574 
  def __repr__(self):
15575 
    L = ['%s=%r' % (key, value)
15576 
      for key, value in self.__dict__.iteritems()]
15577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15578 
 
15579 
  def __eq__(self, other):
15580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15581 
 
15582 
  def __ne__(self, other):
15583 
    return not (self == other)
15584 
 
22721 amit.gupta 15585 
class getFofoFulFillmentWarehouseMap_args:
15586 
  """
15587 
  Attributes:
15588 
   - itemIds
15589 
  """
15590 
 
15591 
  thrift_spec = (
15592 
    None, # 0
15593 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
15594 
  )
15595 
 
15596 
  def __init__(self, itemIds=None,):
15597 
    self.itemIds = itemIds
15598 
 
15599 
  def read(self, iprot):
15600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15602 
      return
15603 
    iprot.readStructBegin()
15604 
    while True:
15605 
      (fname, ftype, fid) = iprot.readFieldBegin()
15606 
      if ftype == TType.STOP:
15607 
        break
15608 
      if fid == 1:
15609 
        if ftype == TType.LIST:
15610 
          self.itemIds = []
15611 
          (_etype393, _size390) = iprot.readListBegin()
15612 
          for _i394 in xrange(_size390):
15613 
            _elem395 = iprot.readI64();
15614 
            self.itemIds.append(_elem395)
15615 
          iprot.readListEnd()
15616 
        else:
15617 
          iprot.skip(ftype)
15618 
      else:
15619 
        iprot.skip(ftype)
15620 
      iprot.readFieldEnd()
15621 
    iprot.readStructEnd()
15622 
 
15623 
  def write(self, oprot):
15624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15626 
      return
15627 
    oprot.writeStructBegin('getFofoFulFillmentWarehouseMap_args')
15628 
    if self.itemIds is not None:
15629 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
15630 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
15631 
      for iter396 in self.itemIds:
15632 
        oprot.writeI64(iter396)
15633 
      oprot.writeListEnd()
15634 
      oprot.writeFieldEnd()
15635 
    oprot.writeFieldStop()
15636 
    oprot.writeStructEnd()
15637 
 
15638 
  def validate(self):
15639 
    return
15640 
 
15641 
 
15642 
  def __repr__(self):
15643 
    L = ['%s=%r' % (key, value)
15644 
      for key, value in self.__dict__.iteritems()]
15645 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15646 
 
15647 
  def __eq__(self, other):
15648 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15649 
 
15650 
  def __ne__(self, other):
15651 
    return not (self == other)
15652 
 
15653 
class getFofoFulFillmentWarehouseMap_result:
15654 
  """
15655 
  Attributes:
15656 
   - success
15657 
  """
15658 
 
15659 
  thrift_spec = (
15660 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRUCT,(Warehouse, Warehouse.thrift_spec)), None, ), # 0
15661 
  )
15662 
 
15663 
  def __init__(self, success=None,):
15664 
    self.success = success
15665 
 
15666 
  def read(self, iprot):
15667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15669 
      return
15670 
    iprot.readStructBegin()
15671 
    while True:
15672 
      (fname, ftype, fid) = iprot.readFieldBegin()
15673 
      if ftype == TType.STOP:
15674 
        break
15675 
      if fid == 0:
15676 
        if ftype == TType.MAP:
15677 
          self.success = {}
15678 
          (_ktype398, _vtype399, _size397 ) = iprot.readMapBegin()
15679 
          for _i401 in xrange(_size397):
15680 
            _key402 = iprot.readI64();
15681 
            _val403 = Warehouse()
15682 
            _val403.read(iprot)
15683 
            self.success[_key402] = _val403
15684 
          iprot.readMapEnd()
15685 
        else:
15686 
          iprot.skip(ftype)
15687 
      else:
15688 
        iprot.skip(ftype)
15689 
      iprot.readFieldEnd()
15690 
    iprot.readStructEnd()
15691 
 
15692 
  def write(self, oprot):
15693 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15694 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15695 
      return
15696 
    oprot.writeStructBegin('getFofoFulFillmentWarehouseMap_result')
15697 
    if self.success is not None:
15698 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15699 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.success))
15700 
      for kiter404,viter405 in self.success.items():
15701 
        oprot.writeI64(kiter404)
15702 
        viter405.write(oprot)
15703 
      oprot.writeMapEnd()
15704 
      oprot.writeFieldEnd()
15705 
    oprot.writeFieldStop()
15706 
    oprot.writeStructEnd()
15707 
 
15708 
  def validate(self):
15709 
    return
15710 
 
15711 
 
15712 
  def __repr__(self):
15713 
    L = ['%s=%r' % (key, value)
15714 
      for key, value in self.__dict__.iteritems()]
15715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15716 
 
15717 
  def __eq__(self, other):
15718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15719 
 
15720 
  def __ne__(self, other):
15721 
    return not (self == other)
15722 
 
19413 amit.gupta 15723 
class getItemLocationAvailabilityCache_args:
15724 
  """
15725 
  Attributes:
15726 
   - itemLocations
15727 
  """
15728 
 
15729 
  thrift_spec = (
15730 
    None, # 0
15731 
    (1, TType.LIST, 'itemLocations', (TType.STRUCT,(ItemLocationAvailability, ItemLocationAvailability.thrift_spec)), None, ), # 1
15732 
  )
15733 
 
15734 
  def __init__(self, itemLocations=None,):
15735 
    self.itemLocations = itemLocations
15736 
 
15737 
  def read(self, iprot):
15738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15740 
      return
15741 
    iprot.readStructBegin()
15742 
    while True:
15743 
      (fname, ftype, fid) = iprot.readFieldBegin()
15744 
      if ftype == TType.STOP:
15745 
        break
15746 
      if fid == 1:
15747 
        if ftype == TType.LIST:
15748 
          self.itemLocations = []
22721 amit.gupta 15749 
          (_etype409, _size406) = iprot.readListBegin()
15750 
          for _i410 in xrange(_size406):
15751 
            _elem411 = ItemLocationAvailability()
15752 
            _elem411.read(iprot)
15753 
            self.itemLocations.append(_elem411)
19413 amit.gupta 15754 
          iprot.readListEnd()
15755 
        else:
15756 
          iprot.skip(ftype)
15757 
      else:
15758 
        iprot.skip(ftype)
15759 
      iprot.readFieldEnd()
15760 
    iprot.readStructEnd()
15761 
 
15762 
  def write(self, oprot):
15763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15765 
      return
15766 
    oprot.writeStructBegin('getItemLocationAvailabilityCache_args')
15767 
    if self.itemLocations is not None:
15768 
      oprot.writeFieldBegin('itemLocations', TType.LIST, 1)
15769 
      oprot.writeListBegin(TType.STRUCT, len(self.itemLocations))
22721 amit.gupta 15770 
      for iter412 in self.itemLocations:
15771 
        iter412.write(oprot)
19413 amit.gupta 15772 
      oprot.writeListEnd()
15773 
      oprot.writeFieldEnd()
15774 
    oprot.writeFieldStop()
15775 
    oprot.writeStructEnd()
15776 
 
15777 
  def validate(self):
15778 
    return
15779 
 
15780 
 
15781 
  def __repr__(self):
15782 
    L = ['%s=%r' % (key, value)
15783 
      for key, value in self.__dict__.iteritems()]
15784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15785 
 
15786 
  def __eq__(self, other):
15787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15788 
 
15789 
  def __ne__(self, other):
15790 
    return not (self == other)
15791 
 
15792 
class getItemLocationAvailabilityCache_result:
15793 
  """
15794 
  Attributes:
15795 
   - success
15796 
  """
15797 
 
15798 
  thrift_spec = (
15799 
    (0, TType.LIST, 'success', (TType.STRUCT,(ItemLocationAvailability, ItemLocationAvailability.thrift_spec)), None, ), # 0
15800 
  )
15801 
 
15802 
  def __init__(self, success=None,):
15803 
    self.success = success
15804 
 
15805 
  def read(self, iprot):
15806 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15807 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15808 
      return
15809 
    iprot.readStructBegin()
15810 
    while True:
15811 
      (fname, ftype, fid) = iprot.readFieldBegin()
15812 
      if ftype == TType.STOP:
15813 
        break
15814 
      if fid == 0:
15815 
        if ftype == TType.LIST:
15816 
          self.success = []
22721 amit.gupta 15817 
          (_etype416, _size413) = iprot.readListBegin()
15818 
          for _i417 in xrange(_size413):
15819 
            _elem418 = ItemLocationAvailability()
15820 
            _elem418.read(iprot)
15821 
            self.success.append(_elem418)
19413 amit.gupta 15822 
          iprot.readListEnd()
15823 
        else:
15824 
          iprot.skip(ftype)
15825 
      else:
15826 
        iprot.skip(ftype)
15827 
      iprot.readFieldEnd()
15828 
    iprot.readStructEnd()
15829 
 
15830 
  def write(self, oprot):
15831 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15832 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15833 
      return
15834 
    oprot.writeStructBegin('getItemLocationAvailabilityCache_result')
15835 
    if self.success is not None:
15836 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15837 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
22721 amit.gupta 15838 
      for iter419 in self.success:
15839 
        iter419.write(oprot)
19413 amit.gupta 15840 
      oprot.writeListEnd()
15841 
      oprot.writeFieldEnd()
15842 
    oprot.writeFieldStop()
15843 
    oprot.writeStructEnd()
15844 
 
15845 
  def validate(self):
15846 
    return
15847 
 
15848 
 
15849 
  def __repr__(self):
15850 
    L = ['%s=%r' % (key, value)
15851 
      for key, value in self.__dict__.iteritems()]
15852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15853 
 
15854 
  def __eq__(self, other):
15855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15856 
 
15857 
  def __ne__(self, other):
15858 
    return not (self == other)
15859 
 
15860 
class getItemLocationAvailabilityCacheByItemId_args:
15861 
  """
15862 
  Attributes:
15863 
   - itemIds
15864 
  """
15865 
 
15866 
  thrift_spec = (
15867 
    None, # 0
15868 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
15869 
  )
15870 
 
15871 
  def __init__(self, itemIds=None,):
15872 
    self.itemIds = itemIds
15873 
 
15874 
  def read(self, iprot):
15875 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15876 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15877 
      return
15878 
    iprot.readStructBegin()
15879 
    while True:
15880 
      (fname, ftype, fid) = iprot.readFieldBegin()
15881 
      if ftype == TType.STOP:
15882 
        break
15883 
      if fid == 1:
15884 
        if ftype == TType.LIST:
15885 
          self.itemIds = []
22721 amit.gupta 15886 
          (_etype423, _size420) = iprot.readListBegin()
15887 
          for _i424 in xrange(_size420):
15888 
            _elem425 = iprot.readI64();
15889 
            self.itemIds.append(_elem425)
19413 amit.gupta 15890 
          iprot.readListEnd()
15891 
        else:
15892 
          iprot.skip(ftype)
15893 
      else:
15894 
        iprot.skip(ftype)
15895 
      iprot.readFieldEnd()
15896 
    iprot.readStructEnd()
15897 
 
15898 
  def write(self, oprot):
15899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15901 
      return
15902 
    oprot.writeStructBegin('getItemLocationAvailabilityCacheByItemId_args')
15903 
    if self.itemIds is not None:
15904 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
15905 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
22721 amit.gupta 15906 
      for iter426 in self.itemIds:
15907 
        oprot.writeI64(iter426)
19413 amit.gupta 15908 
      oprot.writeListEnd()
15909 
      oprot.writeFieldEnd()
15910 
    oprot.writeFieldStop()
15911 
    oprot.writeStructEnd()
15912 
 
15913 
  def validate(self):
15914 
    return
15915 
 
15916 
 
15917 
  def __repr__(self):
15918 
    L = ['%s=%r' % (key, value)
15919 
      for key, value in self.__dict__.iteritems()]
15920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15921 
 
15922 
  def __eq__(self, other):
15923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15924 
 
15925 
  def __ne__(self, other):
15926 
    return not (self == other)
15927 
 
15928 
class getItemLocationAvailabilityCacheByItemId_result:
15929 
  """
15930 
  Attributes:
15931 
   - success
15932 
  """
15933 
 
15934 
  thrift_spec = (
15935 
    (0, TType.LIST, 'success', (TType.STRUCT,(ItemLocationAvailability, ItemLocationAvailability.thrift_spec)), None, ), # 0
15936 
  )
15937 
 
15938 
  def __init__(self, success=None,):
15939 
    self.success = success
15940 
 
15941 
  def read(self, iprot):
15942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15944 
      return
15945 
    iprot.readStructBegin()
15946 
    while True:
15947 
      (fname, ftype, fid) = iprot.readFieldBegin()
15948 
      if ftype == TType.STOP:
15949 
        break
15950 
      if fid == 0:
15951 
        if ftype == TType.LIST:
15952 
          self.success = []
22721 amit.gupta 15953 
          (_etype430, _size427) = iprot.readListBegin()
15954 
          for _i431 in xrange(_size427):
15955 
            _elem432 = ItemLocationAvailability()
15956 
            _elem432.read(iprot)
15957 
            self.success.append(_elem432)
19413 amit.gupta 15958 
          iprot.readListEnd()
15959 
        else:
15960 
          iprot.skip(ftype)
15961 
      else:
15962 
        iprot.skip(ftype)
15963 
      iprot.readFieldEnd()
15964 
    iprot.readStructEnd()
15965 
 
15966 
  def write(self, oprot):
15967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15969 
      return
15970 
    oprot.writeStructBegin('getItemLocationAvailabilityCacheByItemId_result')
15971 
    if self.success is not None:
15972 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15973 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
22721 amit.gupta 15974 
      for iter433 in self.success:
15975 
        iter433.write(oprot)
19413 amit.gupta 15976 
      oprot.writeListEnd()
15977 
      oprot.writeFieldEnd()
15978 
    oprot.writeFieldStop()
15979 
    oprot.writeStructEnd()
15980 
 
15981 
  def validate(self):
15982 
    return
15983 
 
15984 
 
15985 
  def __repr__(self):
15986 
    L = ['%s=%r' % (key, value)
15987 
      for key, value in self.__dict__.iteritems()]
15988 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15989 
 
15990 
  def __eq__(self, other):
15991 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15992 
 
15993 
  def __ne__(self, other):
15994 
    return not (self == other)
15995 
 
15996 
class getItemPincodeAvailability_args:
15997 
  """
15998 
  Attributes:
19416 amit.gupta 15999 
   - itempricing
19413 amit.gupta 16000 
   - pincode
16001 
  """
16002 
 
16003 
  thrift_spec = (
16004 
    None, # 0
19416 amit.gupta 16005 
    (1, TType.MAP, 'itempricing', (TType.I64,None,TType.I64,None), None, ), # 1
19413 amit.gupta 16006 
    (2, TType.STRING, 'pincode', None, None, ), # 2
16007 
  )
16008 
 
19416 amit.gupta 16009 
  def __init__(self, itempricing=None, pincode=None,):
16010 
    self.itempricing = itempricing
19413 amit.gupta 16011 
    self.pincode = pincode
16012 
 
16013 
  def read(self, iprot):
16014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16016 
      return
16017 
    iprot.readStructBegin()
16018 
    while True:
16019 
      (fname, ftype, fid) = iprot.readFieldBegin()
16020 
      if ftype == TType.STOP:
16021 
        break
16022 
      if fid == 1:
19416 amit.gupta 16023 
        if ftype == TType.MAP:
16024 
          self.itempricing = {}
22721 amit.gupta 16025 
          (_ktype435, _vtype436, _size434 ) = iprot.readMapBegin()
16026 
          for _i438 in xrange(_size434):
16027 
            _key439 = iprot.readI64();
16028 
            _val440 = iprot.readI64();
16029 
            self.itempricing[_key439] = _val440
19416 amit.gupta 16030 
          iprot.readMapEnd()
19413 amit.gupta 16031 
        else:
16032 
          iprot.skip(ftype)
16033 
      elif fid == 2:
16034 
        if ftype == TType.STRING:
16035 
          self.pincode = iprot.readString();
16036 
        else:
16037 
          iprot.skip(ftype)
16038 
      else:
16039 
        iprot.skip(ftype)
16040 
      iprot.readFieldEnd()
16041 
    iprot.readStructEnd()
16042 
 
16043 
  def write(self, oprot):
16044 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16045 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16046 
      return
16047 
    oprot.writeStructBegin('getItemPincodeAvailability_args')
19416 amit.gupta 16048 
    if self.itempricing is not None:
16049 
      oprot.writeFieldBegin('itempricing', TType.MAP, 1)
16050 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.itempricing))
22721 amit.gupta 16051 
      for kiter441,viter442 in self.itempricing.items():
16052 
        oprot.writeI64(kiter441)
16053 
        oprot.writeI64(viter442)
19416 amit.gupta 16054 
      oprot.writeMapEnd()
19413 amit.gupta 16055 
      oprot.writeFieldEnd()
16056 
    if self.pincode is not None:
16057 
      oprot.writeFieldBegin('pincode', TType.STRING, 2)
16058 
      oprot.writeString(self.pincode)
16059 
      oprot.writeFieldEnd()
16060 
    oprot.writeFieldStop()
16061 
    oprot.writeStructEnd()
16062 
 
16063 
  def validate(self):
16064 
    return
16065 
 
16066 
 
16067 
  def __repr__(self):
16068 
    L = ['%s=%r' % (key, value)
16069 
      for key, value in self.__dict__.iteritems()]
16070 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16071 
 
16072 
  def __eq__(self, other):
16073 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16074 
 
16075 
  def __ne__(self, other):
16076 
    return not (self == other)
16077 
 
16078 
class getItemPincodeAvailability_result:
16079 
  """
16080 
  Attributes:
16081 
   - success
16082 
  """
16083 
 
16084 
  thrift_spec = (
16085 
    (0, TType.STRING, 'success', None, None, ), # 0
16086 
  )
16087 
 
16088 
  def __init__(self, success=None,):
16089 
    self.success = success
16090 
 
16091 
  def read(self, iprot):
16092 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16093 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16094 
      return
16095 
    iprot.readStructBegin()
16096 
    while True:
16097 
      (fname, ftype, fid) = iprot.readFieldBegin()
16098 
      if ftype == TType.STOP:
16099 
        break
16100 
      if fid == 0:
16101 
        if ftype == TType.STRING:
16102 
          self.success = iprot.readString();
16103 
        else:
16104 
          iprot.skip(ftype)
16105 
      else:
16106 
        iprot.skip(ftype)
16107 
      iprot.readFieldEnd()
16108 
    iprot.readStructEnd()
16109 
 
16110 
  def write(self, oprot):
16111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16113 
      return
16114 
    oprot.writeStructBegin('getItemPincodeAvailability_result')
16115 
    if self.success is not None:
16116 
      oprot.writeFieldBegin('success', TType.STRING, 0)
16117 
      oprot.writeString(self.success)
16118 
      oprot.writeFieldEnd()
16119 
    oprot.writeFieldStop()
16120 
    oprot.writeStructEnd()
16121 
 
16122 
  def validate(self):
16123 
    return
16124 
 
16125 
 
16126 
  def __repr__(self):
16127 
    L = ['%s=%r' % (key, value)
16128 
      for key, value in self.__dict__.iteritems()]
16129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16130 
 
16131 
  def __eq__(self, other):
16132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16133 
 
16134 
  def __ne__(self, other):
16135 
    return not (self == other)