Subversion Repositories SmartDukaan

#

# Autogenerated by Thrift Compiler (0.7.0)

#

# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING

#

from thrift.Thrift import *

import shop2020.thriftpy.generic.GenericService

from ttypes import *

from thrift.Thrift import TProcessor

from thrift.transport import TTransport

from thrift.protocol import TBinaryProtocol, TProtocol

try:

  from thrift.protocol import fastbinary

except:

  fastbinary = None

class Iface(shop2020.thriftpy.generic.GenericService.Iface):

  def getLatestPricing(self, skuBundleId, source_id):

    """

    Parameters:

     - skuBundleId

     - source_id

    """

    pass

  def updateLatestPriceForItem(self, id):

    """

    Parameters:

     - id

    """

    pass

  def addItemsInBulk(self, bulkItemsList):

    """

    Parameters:

     - bulkItemsList

    """

    pass

class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):

  def __init__(self, iprot, oprot=None):

    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)

  def getLatestPricing(self, skuBundleId, source_id):

    """

    Parameters:

     - skuBundleId

     - source_id

    """

    self.send_getLatestPricing(skuBundleId, source_id)

    return self.recv_getLatestPricing()

  def send_getLatestPricing(self, skuBundleId, source_id):

    self._oprot.writeMessageBegin('getLatestPricing', TMessageType.CALL, self._seqid)

    args = getLatestPricing_args()

    args.skuBundleId = skuBundleId

    args.source_id = source_id

    args.write(self._oprot)

    self._oprot.writeMessageEnd()

    self._oprot.trans.flush()

  def recv_getLatestPricing(self, ):

    (fname, mtype, rseqid) = self._iprot.readMessageBegin()

    if mtype == TMessageType.EXCEPTION:

      x = TApplicationException()

      x.read(self._iprot)

      self._iprot.readMessageEnd()

      raise x

    result = getLatestPricing_result()

    result.read(self._iprot)

    self._iprot.readMessageEnd()

    if result.success is not None:

      return result.success

    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestPricing failed: unknown result");

  def updateLatestPriceForItem(self, id):

    """

    Parameters:

     - id

    """

    self.send_updateLatestPriceForItem(id)

  def send_updateLatestPriceForItem(self, id):

    self._oprot.writeMessageBegin('updateLatestPriceForItem', TMessageType.CALL, self._seqid)

    args = updateLatestPriceForItem_args()

    args.id = id

    args.write(self._oprot)

    self._oprot.writeMessageEnd()

    self._oprot.trans.flush()

  def addItemsInBulk(self, bulkItemsList):

    """

    Parameters:

     - bulkItemsList

    """

    self.send_addItemsInBulk(bulkItemsList)

    return self.recv_addItemsInBulk()

  def send_addItemsInBulk(self, bulkItemsList):

    self._oprot.writeMessageBegin('addItemsInBulk', TMessageType.CALL, self._seqid)

    args = addItemsInBulk_args()

    args.bulkItemsList = bulkItemsList

    args.write(self._oprot)

    self._oprot.writeMessageEnd()

    self._oprot.trans.flush()

  def recv_addItemsInBulk(self, ):

    (fname, mtype, rseqid) = self._iprot.readMessageBegin()

    if mtype == TMessageType.EXCEPTION:

      x = TApplicationException()

      x.read(self._iprot)

      self._iprot.readMessageEnd()

      raise x

    result = addItemsInBulk_result()

    result.read(self._iprot)

    self._iprot.readMessageEnd()

    if result.success is not None:

      return result.success

    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemsInBulk failed: unknown result");

class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):

  def __init__(self, handler):

    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)

    self._processMap["getLatestPricing"] = Processor.process_getLatestPricing

    self._processMap["updateLatestPriceForItem"] = Processor.process_updateLatestPriceForItem

    self._processMap["addItemsInBulk"] = Processor.process_addItemsInBulk

  def process(self, iprot, oprot):

    (name, type, seqid) = iprot.readMessageBegin()

    if name not in self._processMap:

      iprot.skip(TType.STRUCT)

      iprot.readMessageEnd()

      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))

      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)

      x.write(oprot)

      oprot.writeMessageEnd()

      oprot.trans.flush()

      return

    else:

      self._processMap[name](self, seqid, iprot, oprot)

    return True

  def process_getLatestPricing(self, seqid, iprot, oprot):

    args = getLatestPricing_args()

    args.read(iprot)

    iprot.readMessageEnd()

    result = getLatestPricing_result()

    result.success = self._handler.getLatestPricing(args.skuBundleId, args.source_id)

    oprot.writeMessageBegin("getLatestPricing", TMessageType.REPLY, seqid)

    result.write(oprot)

    oprot.writeMessageEnd()

    oprot.trans.flush()

  def process_updateLatestPriceForItem(self, seqid, iprot, oprot):

    args = updateLatestPriceForItem_args()

    args.read(iprot)

    iprot.readMessageEnd()

    self._handler.updateLatestPriceForItem(args.id)

    return

  def process_addItemsInBulk(self, seqid, iprot, oprot):

    args = addItemsInBulk_args()

    args.read(iprot)

    iprot.readMessageEnd()

    result = addItemsInBulk_result()

    result.success = self._handler.addItemsInBulk(args.bulkItemsList)

    oprot.writeMessageBegin("addItemsInBulk", TMessageType.REPLY, seqid)

    result.write(oprot)

    oprot.writeMessageEnd()

    oprot.trans.flush()

# HELPER FUNCTIONS AND STRUCTURES

class getLatestPricing_args:

  """

  Attributes:

   - skuBundleId

   - source_id

  """

  thrift_spec = (

    None, # 0

    (1, TType.I64, 'skuBundleId', None, None, ), # 1

    (2, TType.I64, 'source_id', None, None, ), # 2

  )

  def __init__(self, skuBundleId=None, source_id=None,):

    self.skuBundleId = skuBundleId

    self.source_id = source_id

  def read(self, iprot):

    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:

      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))

      return

    iprot.readStructBegin()

    while True:

      (fname, ftype, fid) = iprot.readFieldBegin()

      if ftype == TType.STOP:

        break

      if fid == 1:

        if ftype == TType.I64:

          self.skuBundleId = iprot.readI64();

        else:

          iprot.skip(ftype)

      elif fid == 2:

        if ftype == TType.I64:

          self.source_id = iprot.readI64();

        else:

          iprot.skip(ftype)

      else:

        iprot.skip(ftype)

      iprot.readFieldEnd()

    iprot.readStructEnd()

  def write(self, oprot):

    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:

      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))

      return

    oprot.writeStructBegin('getLatestPricing_args')

    if self.skuBundleId is not None:

      oprot.writeFieldBegin('skuBundleId', TType.I64, 1)

      oprot.writeI64(self.skuBundleId)

      oprot.writeFieldEnd()

    if self.source_id is not None:

      oprot.writeFieldBegin('source_id', TType.I64, 2)

      oprot.writeI64(self.source_id)

      oprot.writeFieldEnd()

    oprot.writeFieldStop()

    oprot.writeStructEnd()

  def validate(self):

    return

  def __repr__(self):

    L = ['%s=%r' % (key, value)

      for key, value in self.__dict__.iteritems()]

    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):

    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):

    return not (self == other)

class getLatestPricing_result:

  """

  Attributes:

   - success

  """

  thrift_spec = (

    (0, TType.LIST, 'success', (TType.STRUCT,(LivePricing, LivePricing.thrift_spec)), None, ), # 0

  )

  def __init__(self, success=None,):

    self.success = success

  def read(self, iprot):

    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:

      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))

      return

    iprot.readStructBegin()

    while True:

      (fname, ftype, fid) = iprot.readFieldBegin()

      if ftype == TType.STOP:

        break

      if fid == 0:

        if ftype == TType.LIST:

          self.success = []

          (_etype3, _size0) = iprot.readListBegin()

          for _i4 in xrange(_size0):

            _elem5 = LivePricing()

            _elem5.read(iprot)

            self.success.append(_elem5)

          iprot.readListEnd()

        else:

          iprot.skip(ftype)

      else:

        iprot.skip(ftype)

      iprot.readFieldEnd()

    iprot.readStructEnd()

  def write(self, oprot):

    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:

      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))

      return

    oprot.writeStructBegin('getLatestPricing_result')

    if self.success is not None:

      oprot.writeFieldBegin('success', TType.LIST, 0)

      oprot.writeListBegin(TType.STRUCT, len(self.success))

      for iter6 in self.success:

        iter6.write(oprot)

      oprot.writeListEnd()

      oprot.writeFieldEnd()

    oprot.writeFieldStop()

    oprot.writeStructEnd()

  def validate(self):

    return

  def __repr__(self):

    L = ['%s=%r' % (key, value)

      for key, value in self.__dict__.iteritems()]

    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):

    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):

    return not (self == other)

class updateLatestPriceForItem_args:

  """

  Attributes:

   - id

  """

  thrift_spec = (

    None, # 0

    (1, TType.I64, 'id', None, None, ), # 1

  )

  def __init__(self, id=None,):

    self.id = id

  def read(self, iprot):

    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:

      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))

      return

    iprot.readStructBegin()

    while True:

      (fname, ftype, fid) = iprot.readFieldBegin()

      if ftype == TType.STOP:

        break

      if fid == 1:

        if ftype == TType.I64:

          self.id = iprot.readI64();

        else:

          iprot.skip(ftype)

      else:

        iprot.skip(ftype)

      iprot.readFieldEnd()

    iprot.readStructEnd()

  def write(self, oprot):

    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:

      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))

      return

    oprot.writeStructBegin('updateLatestPriceForItem_args')

    if self.id is not None:

      oprot.writeFieldBegin('id', TType.I64, 1)

      oprot.writeI64(self.id)

      oprot.writeFieldEnd()

    oprot.writeFieldStop()

    oprot.writeStructEnd()

  def validate(self):

    return

  def __repr__(self):

    L = ['%s=%r' % (key, value)

      for key, value in self.__dict__.iteritems()]

    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):

    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):

    return not (self == other)

class addItemsInBulk_args:

  """

  Attributes:

   - bulkItemsList

  """

  thrift_spec = (

    None, # 0

    (1, TType.LIST, 'bulkItemsList', (TType.STRUCT,(BulkItems, BulkItems.thrift_spec)), None, ), # 1

  )

  def __init__(self, bulkItemsList=None,):

    self.bulkItemsList = bulkItemsList

  def read(self, iprot):

    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:

      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))

      return

    iprot.readStructBegin()

    while True:

      (fname, ftype, fid) = iprot.readFieldBegin()

      if ftype == TType.STOP:

        break

      if fid == 1:

        if ftype == TType.LIST:

          self.bulkItemsList = []

          (_etype10, _size7) = iprot.readListBegin()

          for _i11 in xrange(_size7):

            _elem12 = BulkItems()

            _elem12.read(iprot)

            self.bulkItemsList.append(_elem12)

          iprot.readListEnd()

        else:

          iprot.skip(ftype)

      else:

        iprot.skip(ftype)

      iprot.readFieldEnd()

    iprot.readStructEnd()

  def write(self, oprot):

    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:

      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))

      return

    oprot.writeStructBegin('addItemsInBulk_args')

    if self.bulkItemsList is not None:

      oprot.writeFieldBegin('bulkItemsList', TType.LIST, 1)

      oprot.writeListBegin(TType.STRUCT, len(self.bulkItemsList))

      for iter13 in self.bulkItemsList:

        iter13.write(oprot)

      oprot.writeListEnd()

      oprot.writeFieldEnd()

    oprot.writeFieldStop()

    oprot.writeStructEnd()

  def validate(self):

    return

  def __repr__(self):

    L = ['%s=%r' % (key, value)

      for key, value in self.__dict__.iteritems()]

    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):

    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):

    return not (self == other)

class addItemsInBulk_result:

  """

  Attributes:

   - success

  """

  thrift_spec = (

    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0

  )

  def __init__(self, success=None,):

    self.success = success

  def read(self, iprot):

    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:

      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))

      return

    iprot.readStructBegin()

    while True:

      (fname, ftype, fid) = iprot.readFieldBegin()

      if ftype == TType.STOP:

        break

      if fid == 0:

        if ftype == TType.LIST:

          self.success = []

          (_etype17, _size14) = iprot.readListBegin()

          for _i18 in xrange(_size14):

            _elem19 = iprot.readString();

            self.success.append(_elem19)

          iprot.readListEnd()

        else:

          iprot.skip(ftype)

      else:

        iprot.skip(ftype)

      iprot.readFieldEnd()

    iprot.readStructEnd()

  def write(self, oprot):

    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:

      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))

      return

    oprot.writeStructBegin('addItemsInBulk_result')

    if self.success is not None:

      oprot.writeFieldBegin('success', TType.LIST, 0)

      oprot.writeListBegin(TType.STRING, len(self.success))

      for iter20 in self.success:

        oprot.writeString(iter20)

      oprot.writeListEnd()

      oprot.writeFieldEnd()

    oprot.writeFieldStop()

    oprot.writeStructEnd()

  def validate(self):

    return

  def __repr__(self):

    L = ['%s=%r' % (key, value)

      for key, value in self.__dict__.iteritems()]

    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):

    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):

    return not (self == other)