text:
from thrift.Thrift import TType, TMessageType, TException, TApplicationException

from thrift.transport import TTransport
from thrift.protocol import TBinaryProtocol, TProtocol
try:
  from thrift.protocol import fastbinary
except:
  fastbinary = None

class TDeleteType:
  """
  Specify type of delete:
   - DELETE_COLUMN means exactly one version will be removed,
   - DELETE_COLUMNS means previous versions will also be removed.
  """
  DELETE_COLUMN = 0
  DELETE_COLUMNS = 1

  _VALUES_TO_NAMES = {
    0: "DELETE_COLUMN",
    1: "DELETE_COLUMNS",
  }

  _NAMES_TO_VALUES = {
    "DELETE_COLUMN": 0,
    "DELETE_COLUMNS": 1,
  }

class TDurability:
  """
  Specify Durability:
   - SKIP_WAL means do not write the Mutation to the WAL.
   - ASYNC_WAL means write the Mutation to the WAL asynchronously,
   - SYNC_WAL means write the Mutation to the WAL synchronously,
   - FSYNC_WAL means Write the Mutation to the WAL synchronously and force the entries to disk.
  """
  SKIP_WAL = 1
  ASYNC_WAL = 2
  SYNC_WAL = 3
  FSYNC_WAL = 4

  _VALUES_TO_NAMES = {
    1: "SKIP_WAL",
    2: "ASYNC_WAL",
    3: "SYNC_WAL",
    4: "FSYNC_WAL",
  }

  _NAMES_TO_VALUES = {
    "SKIP_WAL": 1,
    "ASYNC_WAL": 2,
    "SYNC_WAL": 3,
    "FSYNC_WAL": 4,
  }

class TReadType:
  DEFAULT = 1
  STREAM = 2
  PREAD = 3

  _VALUES_TO_NAMES = {
    1: "DEFAULT",
    2: "STREAM",
    3: "PREAD",
  }

  _NAMES_TO_VALUES = {
    "DEFAULT": 1,
    "STREAM": 2,
    "PREAD": 3,
  }

class TCompareOp:
  """
  Thrift wrapper around
  org.apache.hadoop.hbase.filter.CompareFilter$CompareOp.
  """
  LESS = 0
  LESS_OR_EQUAL = 1
  EQUAL = 2
  NOT_EQUAL = 3
  GREATER_OR_EQUAL = 4
  GREATER = 5
  NO_OP = 6

  _VALUES_TO_NAMES = {
    0: "LESS",
    1: "LESS_OR_EQUAL",
    2: "EQUAL",
    3: "NOT_EQUAL",
    4: "GREATER_OR_EQUAL",
    5: "GREATER",
    6: "NO_OP",
  }

  _NAMES_TO_VALUES = {
    "LESS": 0,
    "LESS_OR_EQUAL": 1,
    "EQUAL": 2,
    "NOT_EQUAL": 3,
    "GREATER_OR_EQUAL": 4,
    "GREATER": 5,
    "NO_OP": 6,
  }

class TTimeRange:
  """
  Attributes:
   - minStamp
   - maxStamp
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'minStamp', None, None, ), # 1
    (2, TType.I64, 'maxStamp', None, None, ), # 2
  )

  def __init__(self, minStamp=None, maxStamp=None,):
    self.minStamp = minStamp
    self.maxStamp = maxStamp

  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.minStamp = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I64:
          self.maxStamp = 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('TTimeRange')
    if self.minStamp is not None:
      oprot.writeFieldBegin('minStamp', TType.I64, 1)
      oprot.writeI64(self.minStamp)
      oprot.writeFieldEnd()
    if self.maxStamp is not None:
      oprot.writeFieldBegin('maxStamp', TType.I64, 2)
      oprot.writeI64(self.maxStamp)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    if self.minStamp is None:
      raise TProtocol.TProtocolException(message='Required field minStamp is unset!')
    if self.maxStamp is None:
      raise TProtocol.TProtocolException(message='Required field maxStamp is unset!')
    return

  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.minStamp)
    value = (value * 31) ^ hash(self.maxStamp)
    return value

  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 TColumn:
  """
  Addresses a single cell or multiple cells
  in a HBase table by column family and optionally
  a column qualifier and timestamp

  Attributes:
   - family
   - qualifier
   - timestamp
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'family', None, None, ), # 1
    (2, TType.STRING, 'qualifier', None, None, ), # 2
    (3, TType.I64, 'timestamp', None, None, ), # 3
  )

  def __init__(self, family=None, qualifier=None, timestamp=None,):
    self.family = family
    self.qualifier = qualifier
    self.timestamp = timestamp

  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.STRING:
          self.family = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.qualifier = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.timestamp = 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('TColumn')
    if self.family is not None:
      oprot.writeFieldBegin('family', TType.STRING, 1)
      oprot.writeString(self.family)
      oprot.writeFieldEnd()
    if self.qualifier is not None:
      oprot.writeFieldBegin('qualifier', TType.STRING, 2)
      oprot.writeString(self.qualifier)
      oprot.writeFieldEnd()
    if self.timestamp is not None:
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
      oprot.writeI64(self.timestamp)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    if self.family is None:
      raise TProtocol.TProtocolException(message='Required field family is unset!')
    return

  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.family)
    value = (value * 31) ^ hash(self.qualifier)
    value = (value * 31) ^ hash(self.timestamp)
    return value

  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 TColumnValue:
  """
  Represents a single cell and its value.

  Attributes:
   - family
   - qualifier
   - value
   - timestamp
   - tags
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'family', None, None, ), # 1
    (2, TType.STRING, 'qualifier', None, None, ), # 2
    (3, TType.STRING, 'value', None, None, ), # 3
    (4, TType.I64, 'timestamp', None, None, ), # 4
    (5, TType.STRING, 'tags', None, None, ), # 5
  )

  def __init__(self, family=None, qualifier=None, value=None, timestamp=None, tags=None,):
    self.family = family
    self.qualifier = qualifier
    self.value = value
    self.timestamp = timestamp
    self.tags = tags

  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.STRING:
          self.family = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.qualifier = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.value = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.I64:
          self.timestamp = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.STRING:
          self.tags = iprot.readString()
        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('TColumnValue')
    if self.family is not None:
      oprot.writeFieldBegin('family', TType.STRING, 1)
      oprot.writeString(self.family)
      oprot.writeFieldEnd()
    if self.qualifier is not None:
      oprot.writeFieldBegin('qualifier', TType.STRING, 2)
      oprot.writeString(self.qualifier)
      oprot.writeFieldEnd()
    if self.value is not None:
      oprot.writeFieldBegin('value', TType.STRING, 3)
      oprot.writeString(self.value)
      oprot.writeFieldEnd()
    if self.timestamp is not None:
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
      oprot.writeI64(self.timestamp)
      oprot.writeFieldEnd()
    if self.tags is not None:
      oprot.writeFieldBegin('tags', TType.STRING, 5)
      oprot.writeString(self.tags)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    if self.family is None:
      raise TProtocol.TProtocolException(message='Required field family is unset!')
    if self.qualifier is None:
      raise TProtocol.TProtocolException(message='Required field qualifier is unset!')
    if self.value is None:
      raise TProtocol.TProtocolException(message='Required field value is unset!')
    return

  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.family)
    value = (value * 31) ^ hash(self.qualifier)
    value = (value * 31) ^ hash(self.value)
    value = (value * 31) ^ hash(self.timestamp)
    value = (value * 31) ^ hash(self.tags)
    return value

  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 TColumnIncrement:
  """
  Represents a single cell and the amount to increment it by

  Attributes:
   - family
   - qualifier
   - amount
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'family', None, None, ), # 1
    (2, TType.STRING, 'qualifier', None, None, ), # 2
    (3, TType.I64, 'amount', None, 1, ), # 3
  )

  def __init__(self, family=None, qualifier=None, amount=thrift_spec[3][4],):
    self.family = family
    self.qualifier = qualifier
    self.amount = amount

  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.STRING:
          self.family = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.qualifier = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.amount = 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('TColumnIncrement')
    if self.family is not None:
      oprot.writeFieldBegin('family', TType.STRING, 1)
      oprot.writeString(self.family)
      oprot.writeFieldEnd()
    if self.qualifier is not None:
      oprot.writeFieldBegin('qualifier', TType.STRING, 2)
      oprot.writeString(self.qualifier)
      oprot.writeFieldEnd()
    if self.amount is not None:
      oprot.writeFieldBegin('amount', TType.I64, 3)
      oprot.writeI64(self.amount)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    if self.family is None:
      raise TProtocol.TProtocolException(message='Required field family is unset!')
    if self.qualifier is None:
      raise TProtocol.TProtocolException(message='Required field qualifier is unset!')
    return

  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.family)
    value = (value * 31) ^ hash(self.qualifier)
    value = (value * 31) ^ hash(self.amount)
    return value

  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 TResult:
  """
  if no Result is found, row and columnValues will not be set.

  Attributes:
   - row
   - columnValues
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'row', None, None, ), # 1
    (2, TType.LIST, 'columnValues', (TType.STRUCT,(TColumnValue, TColumnValue.thrift_spec)), None, ), # 2
  )

  def __init__(self, row=None, columnValues=None,):
    self.row = row
    self.columnValues = columnValues

  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.STRING:
          self.row = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.LIST:
          self.columnValues = []
          (_etype3, _size0) = iprot.readListBegin()
          for _i4 in xrange(_size0):
            _elem5 = TColumnValue()
            _elem5.read(iprot)
            self.columnValues.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('TResult')
    if self.row is not None:
      oprot.writeFieldBegin('row', TType.STRING, 1)
      oprot.writeString(self.row)
      oprot.writeFieldEnd()
    if self.columnValues is not None:
      oprot.writeFieldBegin('columnValues', TType.LIST, 2)
      oprot.writeListBegin(TType.STRUCT, len(self.columnValues))
      for iter6 in self.columnValues:
        iter6.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    if self.columnValues is None:
      raise TProtocol.TProtocolException(message='Required field columnValues is unset!')
    return

  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.row)
    value = (value * 31) ^ hash(self.columnValues)
    return value

  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 TAuthorization:
  """
  Attributes:
   - labels
  """

  thrift_spec = (
    None, # 0
    (1, TType.LIST, 'labels', (TType.STRING,None), None, ), # 1
  )

  def __init__(self, labels=None,):
    self.labels = labels

  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.labels = []
          (_etype10, _size7) = iprot.readListBegin()
          for _i11 in xrange(_size7):
            _elem12 = iprot.readString()
            self.labels.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('TAuthorization')
    if self.labels is not None:
      oprot.writeFieldBegin('labels', TType.LIST, 1)
      oprot.writeListBegin(TType.STRING, len(self.labels))
      for iter13 in self.labels:
        oprot.writeString(iter13)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return

  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.labels)
    return value

  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 TCellVisibility:
  """
  Attributes:
   - expression
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'expression', None, None, ), # 1
  )

  def __init__(self, expression=None,):
    self.expression = expression

  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.STRING:
          self.expression = iprot.readString()
        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('TCellVisibility')
    if self.expression is not None:
      oprot.writeFieldBegin('expression', TType.STRING, 1)
      oprot.writeString(self.expression)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return

  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.expression)
    return value

  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 TGet:
  """
  Used to perform Get operations on a single row.

  The scope can be further narrowed down by specifying a list of
  columns or column families.

  To get everything for a row, instantiate a Get object with just the row to get.
  To further define the scope of what to get you can add a timestamp or time range
  with an optional maximum number of versions to return.

  If you specify a time range and a timestamp the range is ignored.
  Timestamps on TColumns are ignored.

  Attributes:
   - row
   - columns
   - timestamp
   - timeRange
   - maxVersions
   - filterString
   - attributes
   - authorizations
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'row', None, None, ), # 1
    (2, TType.LIST, 'columns', (TType.STRUCT,(TColumn, TColumn.thrift_spec)), None, ), # 2
    (3, TType.I64, 'timestamp', None, None, ), # 3
    (4, TType.STRUCT, 'timeRange', (TTimeRange, TTimeRange.thrift_spec), None, ), # 4
    (5, TType.I32, 'maxVersions', None, None, ), # 5
    (6, TType.STRING, 'filterString', None, None, ), # 6
    (7, TType.MAP, 'attributes', (TType.STRING,None,TType.STRING,None), None, ), # 7
    (8, TType.STRUCT, 'authorizations', (TAuthorization, TAuthorization.thrift_spec), None, ), # 8
  )

  def __init__(self, row=None, columns=None, timestamp=None, timeRange=None, maxVersions=None, filterString=None, attributes=None, authorizations=None,):
    self.row = row
    self.columns = columns
    self.timestamp = timestamp
    self.timeRange = timeRange
    self.maxVersions = maxVersions
    self.filterString = filterString
    self.attributes = attributes
    self.authorizations = authorizations

  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.STRING:
          self.row = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.LIST:
          self.columns = []
          (_etype17, _size14) = iprot.readListBegin()
          for _i18 in xrange(_size14):
            _elem19 = TColumn()
            _elem19.read(iprot)
            self.columns.append(_elem19)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.timestamp = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.STRUCT:
          self.timeRange = TTimeRange()
          self.timeRange.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.I32:
          self.maxVersions = iprot.readI32()
        else:
          iprot.skip(ftype)
      elif fid == 6:
        if ftype == TType.STRING:
          self.filterString = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 7:
        if ftype == TType.MAP:
          self.attributes = {}
          (_ktype21, _vtype22, _size20 ) = iprot.readMapBegin()
          for _i24 in xrange(_size20):
            _key25 = iprot.readString()
            _val26 = iprot.readString()
            self.attributes[_key25] = _val26
          iprot.readMapEnd()
        else:
          iprot.skip(ftype)
      elif fid == 8:
        if ftype == TType.STRUCT:
          self.authorizations = TAuthorization()
          self.authorizations.read(iprot)
        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('TGet')
    if self.row is not None:
      oprot.writeFieldBegin('row', TType.STRING, 1)
      oprot.writeString(self.row)
      oprot.writeFieldEnd()
    if self.columns is not None:
      oprot.writeFieldBegin('columns', TType.LIST, 2)
      oprot.writeListBegin(TType.STRUCT, len(self.columns))
      for iter27 in self.columns:
        iter27.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.timestamp is not None:
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
      oprot.writeI64(self.timestamp)
      oprot.writeFieldEnd()
    if self.timeRange is not None:
      oprot.writeFieldBegin('timeRange', TType.STRUCT, 4)
      self.timeRange.write(oprot)
      oprot.writeFieldEnd()
    if self.maxVersions is not None:
      oprot.writeFieldBegin('maxVersions', TType.I32, 5)
      oprot.writeI32(self.maxVersions)
      oprot.writeFieldEnd()
    if self.filterString is not None:
      oprot.writeFieldBegin('filterString', TType.STRING, 6)
      oprot.writeString(self.filterString)
      oprot.writeFieldEnd()
    if self.attributes is not None:
      oprot.writeFieldBegin('attributes', TType.MAP, 7)
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.attributes))
      for kiter28,viter29 in self.attributes.items():
        oprot.writeString(kiter28)
        oprot.writeString(viter29)
      oprot.writeMapEnd()
      oprot.writeFieldEnd()
    if self.authorizations is not None:
      oprot.writeFieldBegin('authorizations', TType.STRUCT, 8)
      self.authorizations.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    if self.row is None:
      raise TProtocol.TProtocolException(message='Required field row is unset!')
    return

  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.row)
    value = (value * 31) ^ hash(self.columns)
    value = (value * 31) ^ hash(self.timestamp)
    value = (value * 31) ^ hash(self.timeRange)
    value = (value * 31) ^ hash(self.maxVersions)
    value = (value * 31) ^ hash(self.filterString)
    value = (value * 31) ^ hash(self.attributes)
    value = (value * 31) ^ hash(self.authorizations)
    return value

  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 TPut:
  """
  Used to perform Put operations for a single row.

  Add column values to this object and they'll be added.
  You can provide a default timestamp if the column values
  don't have one. If you don't provide a default timestamp
  the current time is inserted.

  You can specify how this Put should be written to the write-ahead Log (WAL)
  by changing the durability. If you don't provide durability, it defaults to
  column family's default setting for durability.

  Attributes:
   - row
   - columnValues
   - timestamp
   - attributes
   - durability
   - cellVisibility
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'row', None, None, ), # 1
    (2, TType.LIST, 'columnValues', (TType.STRUCT,(TColumnValue, TColumnValue.thrift_spec)), None, ), # 2
    (3, TType.I64, 'timestamp', None, None, ), # 3
    None, # 4
    (5, TType.MAP, 'attributes', (TType.STRING,None,TType.STRING,None), None, ), # 5
    (6, TType.I32, 'durability', None, None, ), # 6
    (7, TType.STRUCT, 'cellVisibility', (TCellVisibility, TCellVisibility.thrift_spec), None, ), # 7
  )

  def __init__(self, row=None, columnValues=None, timestamp=None, attributes=None, durability=None, cellVisibility=None,):
    self.row = row
    self.columnValues = columnValues
    self.timestamp = timestamp
    self.attributes = attributes
    self.durability = durability
    self.cellVisibility = cellVisibility

  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.STRING:
          self.row = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.LIST:
          self.columnValues = []
          (_etype33, _size30) = iprot.readListBegin()
          for _i34 in xrange(_size30):
            _elem35 = TColumnValue()
            _elem35.read(iprot)
            self.columnValues.append(_elem35)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.timestamp = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.MAP:
          self.attributes = {}
          (_ktype37, _vtype38, _size36 ) = iprot.readMapBegin()
          for _i40 in xrange(_size36):
            _key41 = iprot.readString()
            _val42 = iprot.readString()
            self.attributes[_key41] = _val42
          iprot.readMapEnd()
        else:
          iprot.skip(ftype)
      elif fid == 6:
        if ftype == TType.I32:
          self.durability = iprot.readI32()
        else:
          iprot.skip(ftype)
      elif fid == 7:
        if ftype == TType.STRUCT:
          self.cellVisibility = TCellVisibility()
          self.cellVisibility.read(iprot)
        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('TPut')
    if self.row is not None:
      oprot.writeFieldBegin('row', TType.STRING, 1)
      oprot.writeString(self.row)
      oprot.writeFieldEnd()
    if self.columnValues is not None:
      oprot.writeFieldBegin('columnValues', TType.LIST, 2)
      oprot.writeListBegin(TType.STRUCT, len(self.columnValues))
      for iter43 in self.columnValues:
        iter43.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.timestamp is not None:
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
      oprot.writeI64(self.timestamp)
      oprot.writeFieldEnd()
    if self.attributes is not None:
      oprot.writeFieldBegin('attributes', TType.MAP, 5)
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.attributes))
      for kiter44,viter45 in self.attributes.items():
        oprot.writeString(kiter44)
        oprot.writeString(viter45)
      oprot.writeMapEnd()
      oprot.writeFieldEnd()
    if self.durability is not None:
      oprot.writeFieldBegin('durability', TType.I32, 6)
      oprot.writeI32(self.durability)
      oprot.writeFieldEnd()
    if self.cellVisibility is not None:
      oprot.writeFieldBegin('cellVisibility', TType.STRUCT, 7)
      self.cellVisibility.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    if self.row is None:
      raise TProtocol.TProtocolException(message='Required field row is unset!')
    if self.columnValues is None:
      raise TProtocol.TProtocolException(message='Required field columnValues is unset!')
    return

  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.row)
    value = (value * 31) ^ hash(self.columnValues)
    value = (value * 31) ^ hash(self.timestamp)
    value = (value * 31) ^ hash(self.attributes)
    value = (value * 31) ^ hash(self.durability)
    value = (value * 31) ^ hash(self.cellVisibility)
    return value

  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 TDelete:
  """
  Used to perform Delete operations on a single row.

  The scope can be further narrowed down by specifying a list of
  columns or column families as TColumns.

  Specifying only a family in a TColumn will delete the whole family.
  If a timestamp is specified all versions with a timestamp less than
  or equal to this will be deleted. If no timestamp is specified the
  current time will be used.

  Specifying a family and a column qualifier in a TColumn will delete only
  this qualifier. If a timestamp is specified only versions equal
  to this timestamp will be deleted. If no timestamp is specified the
  most recent version will be deleted.  To delete all previous versions,
  specify the DELETE_COLUMNS TDeleteType.

  The top level timestamp is only used if a complete row should be deleted
  (i.e. no columns are passed) and if it is specified it works the same way
  as if you had added a TColumn for every column family and this timestamp
  (i.e. all versions older than or equal in all column families will be deleted)

  You can specify how this Delete should be written to the write-ahead Log (WAL)
  by changing the durability. If you don't provide durability, it defaults to
  column family's default setting for durability.

  Attributes:
   - row
   - columns
   - timestamp
   - deleteType
   - attributes
   - durability
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'row', None, None, ), # 1
    (2, TType.LIST, 'columns', (TType.STRUCT,(TColumn, TColumn.thrift_spec)), None, ), # 2
    (3, TType.I64, 'timestamp', None, None, ), # 3
    (4, TType.I32, 'deleteType', None,     1, ), # 4
    None, # 5
    (6, TType.MAP, 'attributes', (TType.STRING,None,TType.STRING,None), None, ), # 6
    (7, TType.I32, 'durability', None, None, ), # 7
  )

  def __init__(self, row=None, columns=None, timestamp=None, deleteType=thrift_spec[4][4], attributes=None, durability=None,):
    self.row = row
    self.columns = columns
    self.timestamp = timestamp
    self.deleteType = deleteType
    self.attributes = attributes
    self.durability = durability

  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.STRING:
          self.row = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.LIST:
          self.columns = []
          (_etype49, _size46) = iprot.readListBegin()
          for _i50 in xrange(_size46):
            _elem51 = TColumn()
            _elem51.read(iprot)
            self.columns.append(_elem51)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.timestamp = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.I32:
          self.deleteType = iprot.readI32()
        else:
          iprot.skip(ftype)
      elif fid == 6:
        if ftype == TType.MAP:
          self.attributes = {}
          (_ktype53, _vtype54, _size52 ) = iprot.readMapBegin()
          for _i56 in xrange(_size52):
            _key57 = iprot.readString()
            _val58 = iprot.readString()
            self.attributes[_key57] = _val58
          iprot.readMapEnd()
        else:
          iprot.skip(ftype)
      elif fid == 7:
        if ftype == TType.I32:
          self.durability = iprot.readI32()
        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('TDelete')
    if self.row is not None:
      oprot.writeFieldBegin('row', TType.STRING, 1)
      oprot.writeString(self.row)
      oprot.writeFieldEnd()
    if self.columns is not None:
      oprot.writeFieldBegin('columns', TType.LIST, 2)
      oprot.writeListBegin(TType.STRUCT, len(self.columns))
      for iter59 in self.columns:
        iter59.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.timestamp is not None:
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
      oprot.writeI64(self.timestamp)
      oprot.writeFieldEnd()
    if self.deleteType is not None:
      oprot.writeFieldBegin('deleteType', TType.I32, 4)
      oprot.writeI32(self.deleteType)
      oprot.writeFieldEnd()
    if self.attributes is not None:
      oprot.writeFieldBegin('attributes', TType.MAP, 6)
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.attributes))
      for kiter60,viter61 in self.attributes.items():
        oprot.writeString(kiter60)
        oprot.writeString(viter61)
      oprot.writeMapEnd()
      oprot.writeFieldEnd()
    if self.durability is not None:
      oprot.writeFieldBegin('durability', TType.I32, 7)
      oprot.writeI32(self.durability)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    if self.row is None:
      raise TProtocol.TProtocolException(message='Required field row is unset!')
    return

  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.row)
    value = (value * 31) ^ hash(self.columns)
    value = (value * 31) ^ hash(self.timestamp)
    value = (value * 31) ^ hash(self.deleteType)
    value = (value * 31) ^ hash(self.attributes)
    value = (value * 31) ^ hash(self.durability)
    return value

  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 TIncrement:
  """
  Used to perform Increment operations for a single row.

  You can specify how this Increment should be written to the write-ahead Log (WAL)
  by changing the durability. If you don't provide durability, it defaults to
  column family's default setting for durability.

  Attributes:
   - row
   - columns
   - attributes
   - durability
   - cellVisibility
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'row', None, None, ), # 1
    (2, TType.LIST, 'columns', (TType.STRUCT,(TColumnIncrement, TColumnIncrement.thrift_spec)), None, ), # 2
    None, # 3
    (4, TType.MAP, 'attributes', (TType.STRING,None,TType.STRING,None), None, ), # 4
    (5, TType.I32, 'durability', None, None, ), # 5
    (6, TType.STRUCT, 'cellVisibility', (TCellVisibility, TCellVisibility.thrift_spec), None, ), # 6
  )

  def __init__(self, row=None, columns=None, attributes=None, durability=None, cellVisibility=None,):
    self.row = row
    self.columns = columns
    self.attributes = attributes
    self.durability = durability
    self.cellVisibility = cellVisibility

  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.STRING:
          self.row = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.LIST:
          self.columns = []
          (_etype65, _size62) = iprot.readListBegin()
          for _i66 in xrange(_size62):
            _elem67 = TColumnIncrement()
            _elem67.read(iprot)
            self.columns.append(_elem67)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.MAP:
          self.attributes = {}
          (_ktype69, _vtype70, _size68 ) = iprot.readMapBegin()
          for _i72 in xrange(_size68):
            _key73 = iprot.readString()
            _val74 = iprot.readString()
            self.attributes[_key73] = _val74
          iprot.readMapEnd()
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.I32:
          self.durability = iprot.readI32()
        else:
          iprot.skip(ftype)
      elif fid == 6:
        if ftype == TType.STRUCT:
          self.cellVisibility = TCellVisibility()
          self.cellVisibility.read(iprot)
        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('TIncrement')
    if self.row is not None:
      oprot.writeFieldBegin('row', TType.STRING, 1)
      oprot.writeString(self.row)
      oprot.writeFieldEnd()
    if self.columns is not None:
      oprot.writeFieldBegin('columns', TType.LIST, 2)
      oprot.writeListBegin(TType.STRUCT, len(self.columns))
      for iter75 in self.columns:
        iter75.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.attributes is not None:
      oprot.writeFieldBegin('attributes', TType.MAP, 4)
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.attributes))
      for kiter76,viter77 in self.attributes.items():
        oprot.writeString(kiter76)
        oprot.writeString(viter77)
      oprot.writeMapEnd()
      oprot.writeFieldEnd()
    if self.durability is not None:
      oprot.writeFieldBegin('durability', TType.I32, 5)
      oprot.writeI32(self.durability)
      oprot.writeFieldEnd()
    if self.cellVisibility is not None:
      oprot.writeFieldBegin('cellVisibility', TType.STRUCT, 6)
      self.cellVisibility.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    if self.row is None:
      raise TProtocol.TProtocolException(message='Required field row is unset!')
    if self.columns is None:
      raise TProtocol.TProtocolException(message='Required field columns is unset!')
    return

  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.row)
    value = (value * 31) ^ hash(self.columns)
    value = (value * 31) ^ hash(self.attributes)
    value = (value * 31) ^ hash(self.durability)
    value = (value * 31) ^ hash(self.cellVisibility)
    return value

  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 TAppend:
  """
  Attributes:
   - row
   - columns
   - attributes
   - durability
   - cellVisibility
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'row', None, None, ), # 1
    (2, TType.LIST, 'columns', (TType.STRUCT,(TColumnValue, TColumnValue.thrift_spec)), None, ), # 2
    (3, TType.MAP, 'attributes', (TType.STRING,None,TType.STRING,None), None, ), # 3
    (4, TType.I32, 'durability', None, None, ), # 4
    (5, TType.STRUCT, 'cellVisibility', (TCellVisibility, TCellVisibility.thrift_spec), None, ), # 5
  )

  def __init__(self, row=None, columns=None, attributes=None, durability=None, cellVisibility=None,):
    self.row = row
    self.columns = columns
    self.attributes = attributes
    self.durability = durability
    self.cellVisibility = cellVisibility

  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.STRING:
          self.row = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.LIST:
          self.columns = []
          (_etype81, _size78) = iprot.readListBegin()
          for _i82 in xrange(_size78):
            _elem83 = TColumnValue()
            _elem83.read(iprot)
            self.columns.append(_elem83)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.MAP:
          self.attributes = {}
          (_ktype85, _vtype86, _size84 ) = iprot.readMapBegin()
          for _i88 in xrange(_size84):
            _key89 = iprot.readString()
            _val90 = iprot.readString()
            self.attributes[_key89] = _val90
          iprot.readMapEnd()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.I32:
          self.durability = iprot.readI32()
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.STRUCT:
          self.cellVisibility = TCellVisibility()
          self.cellVisibility.read(iprot)
        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('TAppend')
    if self.row is not None:
      oprot.writeFieldBegin('row', TType.STRING, 1)
      oprot.writeString(self.row)
      oprot.writeFieldEnd()
    if self.columns is not None:
      oprot.writeFieldBegin('columns', TType.LIST, 2)
      oprot.writeListBegin(TType.STRUCT, len(self.columns))
      for iter91 in self.columns:
        iter91.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.attributes is not None:
      oprot.writeFieldBegin('attributes', TType.MAP, 3)
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.attributes))
      for kiter92,viter93 in self.attributes.items():
        oprot.writeString(kiter92)
        oprot.writeString(viter93)
      oprot.writeMapEnd()
      oprot.writeFieldEnd()
    if self.durability is not None:
      oprot.writeFieldBegin('durability', TType.I32, 4)
      oprot.writeI32(self.durability)
      oprot.writeFieldEnd()
    if self.cellVisibility is not None:
      oprot.writeFieldBegin('cellVisibility', TType.STRUCT, 5)
      self.cellVisibility.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    if self.row is None:
      raise TProtocol.TProtocolException(message='Required field row is unset!')
    if self.columns is None:
      raise TProtocol.TProtocolException(message='Required field columns is unset!')
    return

  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.row)
    value = (value * 31) ^ hash(self.columns)
    value = (value * 31) ^ hash(self.attributes)
    value = (value * 31) ^ hash(self.durability)
    value = (value * 31) ^ hash(self.cellVisibility)
    return value

  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 TScan:
  """
  Any timestamps in the columns are ignored but the colFamTimeRangeMap included, use timeRange to select by timestamp.
  Max versions defaults to 1.

  Attributes:
   - startRow
   - stopRow
   - columns
   - caching
   - maxVersions
   - timeRange
   - filterString
   - batchSize
   - attributes
   - authorizations
   - reversed
   - cacheBlocks
   - colFamTimeRangeMap
   - readType
   - limit
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'startRow', None, None, ), # 1
    (2, TType.STRING, 'stopRow', None, None, ), # 2
    (3, TType.LIST, 'columns', (TType.STRUCT,(TColumn, TColumn.thrift_spec)), None, ), # 3
    (4, TType.I32, 'caching', None, None, ), # 4
    (5, TType.I32, 'maxVersions', None, 1, ), # 5
    (6, TType.STRUCT, 'timeRange', (TTimeRange, TTimeRange.thrift_spec), None, ), # 6
    (7, TType.STRING, 'filterString', None, None, ), # 7
    (8, TType.I32, 'batchSize', None, None, ), # 8
    (9, TType.MAP, 'attributes', (TType.STRING,None,TType.STRING,None), None, ), # 9
    (10, TType.STRUCT, 'authorizations', (TAuthorization, TAuthorization.thrift_spec), None, ), # 10
    (11, TType.BOOL, 'reversed', None, None, ), # 11
    (12, TType.BOOL, 'cacheBlocks', None, None, ), # 12
    (13, TType.MAP, 'colFamTimeRangeMap', (TType.STRING,None,TType.STRUCT,(TTimeRange, TTimeRange.thrift_spec)), None, ), # 13
    (14, TType.I32, 'readType', None, None, ), # 14
    (15, TType.I32, 'limit', None, None, ), # 15
  )

  def __init__(self, startRow=None, stopRow=None, columns=None, caching=None, maxVersions=thrift_spec[5][4], timeRange=None, filterString=None, batchSize=None, attributes=None, authorizations=None, reversed=None, cacheBlocks=None, colFamTimeRangeMap=None, readType=None, limit=None,):
    self.startRow = startRow
    self.stopRow = stopRow
    self.columns = columns
    self.caching = caching
    self.maxVersions = maxVersions
    self.timeRange = timeRange
    self.filterString = filterString
    self.batchSize = batchSize
    self.attributes = attributes
    self.authorizations = authorizations
    self.reversed = reversed
    self.cacheBlocks = cacheBlocks
    self.colFamTimeRangeMap = colFamTimeRangeMap
    self.readType = readType
    self.limit = limit

  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.STRING:
          self.startRow = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.stopRow = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.LIST:
          self.columns = []
          (_etype97, _size94) = iprot.readListBegin()
          for _i98 in xrange(_size94):
            _elem99 = TColumn()
            _elem99.read(iprot)
            self.columns.append(_elem99)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.I32:
          self.caching = iprot.readI32()
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.I32:
          self.maxVersions = iprot.readI32()
        else:
          iprot.skip(ftype)
      elif fid == 6:
        if ftype == TType.STRUCT:
          self.timeRange = TTimeRange()
          self.timeRange.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 7:
        if ftype == TType.STRING:
          self.filterString = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 8:
        if ftype == TType.I32:
          self.batchSize = iprot.readI32()
        else:
          iprot.skip(ftype)
      elif fid == 9:
        if ftype == TType.MAP:
          self.attributes = {}
          (_ktype101, _vtype102, _size100 ) = iprot.readMapBegin()
          for _i104 in xrange(_size100):
            _key105 = iprot.readString()
            _val106 = iprot.readString()
            self.attributes[_key105] = _val106
          iprot.readMapEnd()
        else:
          iprot.skip(ftype)
      elif fid == 10:
        if ftype == TType.STRUCT:
          self.authorizations = TAuthorization()
          self.authorizations.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 11:
        if ftype == TType.BOOL:
          self.reversed = iprot.readBool()
        else:
          iprot.skip(ftype)
      elif fid == 12:
        if ftype == TType.BOOL:
          self.cacheBlocks = iprot.readBool()
        else:
          iprot.skip(ftype)
      elif fid == 13:
        if ftype == TType.MAP:
          self.colFamTimeRangeMap = {}
          (_ktype108, _vtype109, _size107 ) = iprot.readMapBegin()
          for _i111 in xrange(_size107):
            _key112 = iprot.readString()
            _val113 = TTimeRange()
            _val113.read(iprot)
            self.colFamTimeRangeMap[_key112] = _val113
          iprot.readMapEnd()
        else:
          iprot.skip(ftype)
      elif fid == 14:
        if ftype == TType.I32:
          self.readType = iprot.readI32()
        else:
          iprot.skip(ftype)
      elif fid == 15:
        if ftype == TType.I32:
          self.limit = iprot.readI32()
        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('TScan')
    if self.startRow is not None:
      oprot.writeFieldBegin('startRow', TType.STRING, 1)
      oprot.writeString(self.startRow)
      oprot.writeFieldEnd()
    if self.stopRow is not None:
      oprot.writeFieldBegin('stopRow', TType.STRING, 2)
      oprot.writeString(self.stopRow)
      oprot.writeFieldEnd()
    if self.columns is not None:
      oprot.writeFieldBegin('columns', TType.LIST, 3)
      oprot.writeListBegin(TType.STRUCT, len(self.columns))
      for iter114 in self.columns:
        iter114.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.caching is not None:
      oprot.writeFieldBegin('caching', TType.I32, 4)
      oprot.writeI32(self.caching)
      oprot.writeFieldEnd()
    if self.maxVersions is not None:
      oprot.writeFieldBegin('maxVersions', TType.I32, 5)
      oprot.writeI32(self.maxVersions)
      oprot.writeFieldEnd()
    if self.timeRange is not None:
      oprot.writeFieldBegin('timeRange', TType.STRUCT, 6)
      self.timeRange.write(oprot)
      oprot.writeFieldEnd()
    if self.filterString is not None:
      oprot.writeFieldBegin('filterString', TType.STRING, 7)
      oprot.writeString(self.filterString)
      oprot.writeFieldEnd()
    if self.batchSize is not None:
      oprot.writeFieldBegin('batchSize', TType.I32, 8)
      oprot.writeI32(self.batchSize)
      oprot.writeFieldEnd()
    if self.attributes is not None:
      oprot.writeFieldBegin('attributes', TType.MAP, 9)
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.attributes))
      for kiter115,viter116 in self.attributes.items():
        oprot.writeString(kiter115)
        oprot.writeString(viter116)
      oprot.writeMapEnd()
      oprot.writeFieldEnd()
    if self.authorizations is not None:
      oprot.writeFieldBegin('authorizations', TType.STRUCT, 10)
      self.authorizations.write(oprot)
      oprot.writeFieldEnd()
    if self.reversed is not None:
      oprot.writeFieldBegin('reversed', TType.BOOL, 11)
      oprot.writeBool(self.reversed)
      oprot.writeFieldEnd()
    if self.cacheBlocks is not None:
      oprot.writeFieldBegin('cacheBlocks', TType.BOOL, 12)
      oprot.writeBool(self.cacheBlocks)
      oprot.writeFieldEnd()
    if self.colFamTimeRangeMap is not None:
      oprot.writeFieldBegin('colFamTimeRangeMap', TType.MAP, 13)
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.colFamTimeRangeMap))
      for kiter117,viter118 in self.colFamTimeRangeMap.items():
        oprot.writeString(kiter117)
        viter118.write(oprot)
      oprot.writeMapEnd()
      oprot.writeFieldEnd()
    if self.readType is not None:
      oprot.writeFieldBegin('readType', TType.I32, 14)
      oprot.writeI32(self.readType)
      oprot.writeFieldEnd()
    if self.limit is not None:
      oprot.writeFieldBegin('limit', TType.I32, 15)
      oprot.writeI32(self.limit)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return

  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.startRow)
    value = (value * 31) ^ hash(self.stopRow)
    value = (value * 31) ^ hash(self.columns)
    value = (value * 31) ^ hash(self.caching)
    value = (value * 31) ^ hash(self.maxVersions)
    value = (value * 31) ^ hash(self.timeRange)
    value = (value * 31) ^ hash(self.filterString)
    value = (value * 31) ^ hash(self.batchSize)
    value = (value * 31) ^ hash(self.attributes)
    value = (value * 31) ^ hash(self.authorizations)
    value = (value * 31) ^ hash(self.reversed)
    value = (value * 31) ^ hash(self.cacheBlocks)
    value = (value * 31) ^ hash(self.colFamTimeRangeMap)
    value = (value * 31) ^ hash(self.readType)
    value = (value * 31) ^ hash(self.limit)
    return value

  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 TMutation:
  """
  Atomic mutation for the specified row. It can be either Put or Delete.

  Attributes:
   - put
   - deleteSingle
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'put', (TPut, TPut.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'deleteSingle', (TDelete, TDelete.thrift_spec), None, ), # 2
  )

  def __init__(self, put=None, deleteSingle=None,):
    self.put = put
    self.deleteSingle = deleteSingle

  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.STRUCT:
          self.put = TPut()
          self.put.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.deleteSingle = TDelete()
          self.deleteSingle.read(iprot)
        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('TMutation')
    if self.put is not None:
      oprot.writeFieldBegin('put', TType.STRUCT, 1)
      self.put.write(oprot)
      oprot.writeFieldEnd()
    if self.deleteSingle is not None:
      oprot.writeFieldBegin('deleteSingle', TType.STRUCT, 2)
      self.deleteSingle.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return

  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.put)
    value = (value * 31) ^ hash(self.deleteSingle)
    return value

  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 TRowMutations:
  """
  A TRowMutations object is used to apply a number of Mutations to a single row.

  Attributes:
   - row
   - mutations
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'row', None, None, ), # 1
    (2, TType.LIST, 'mutations', (TType.STRUCT,(TMutation, TMutation.thrift_spec)), None, ), # 2
  )

  def __init__(self, row=None, mutations=None,):
    self.row = row
    self.mutations = mutations

  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.STRING:
          self.row = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.LIST:
          self.mutations = []
          (_etype122, _size119) = iprot.readListBegin()
          for _i123 in xrange(_size119):
            _elem124 = TMutation()
            _elem124.read(iprot)
            self.mutations.append(_elem124)
          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('TRowMutations')
    if self.row is not None:
      oprot.writeFieldBegin('row', TType.STRING, 1)
      oprot.writeString(self.row)
      oprot.writeFieldEnd()
    if self.mutations is not None:
      oprot.writeFieldBegin('mutations', TType.LIST, 2)
      oprot.writeListBegin(TType.STRUCT, len(self.mutations))
      for iter125 in self.mutations:
        iter125.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    if self.row is None:
      raise TProtocol.TProtocolException(message='Required field row is unset!')
    if self.mutations is None:
      raise TProtocol.TProtocolException(message='Required field mutations is unset!')
    return

  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.row)
    value = (value * 31) ^ hash(self.mutations)
    return value

  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 THRegionInfo:
  """
  Attributes:
   - regionId
   - tableName
   - startKey
   - endKey
   - offline
   - split
   - replicaId
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'regionId', None, None, ), # 1
    (2, TType.STRING, 'tableName', None, None, ), # 2
    (3, TType.STRING, 'startKey', None, None, ), # 3
    (4, TType.STRING, 'endKey', None, None, ), # 4
    (5, TType.BOOL, 'offline', None, None, ), # 5
    (6, TType.BOOL, 'split', None, None, ), # 6
    (7, TType.I32, 'replicaId', None, None, ), # 7
  )

  def __init__(self, regionId=None, tableName=None, startKey=None, endKey=None, offline=None, split=None, replicaId=None,):
    self.regionId = regionId
    self.tableName = tableName
    self.startKey = startKey
    self.endKey = endKey
    self.offline = offline
    self.split = split
    self.replicaId = replicaId

  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.regionId = iprot.readI64()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.tableName = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.startKey = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.STRING:
          self.endKey = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.BOOL:
          self.offline = iprot.readBool()
        else:
          iprot.skip(ftype)
      elif fid == 6:
        if ftype == TType.BOOL:
          self.split = iprot.readBool()
        else:
          iprot.skip(ftype)
      elif fid == 7:
        if ftype == TType.I32:
          self.replicaId = iprot.readI32()
        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('THRegionInfo')
    if self.regionId is not None:
      oprot.writeFieldBegin('regionId', TType.I64, 1)
      oprot.writeI64(self.regionId)
      oprot.writeFieldEnd()
    if self.tableName is not None:
      oprot.writeFieldBegin('tableName', TType.STRING, 2)
      oprot.writeString(self.tableName)
      oprot.writeFieldEnd()
    if self.startKey is not None:
      oprot.writeFieldBegin('startKey', TType.STRING, 3)
      oprot.writeString(self.startKey)
      oprot.writeFieldEnd()
    if self.endKey is not None:
      oprot.writeFieldBegin('endKey', TType.STRING, 4)
      oprot.writeString(self.endKey)
      oprot.writeFieldEnd()
    if self.offline is not None:
      oprot.writeFieldBegin('offline', TType.BOOL, 5)
      oprot.writeBool(self.offline)
      oprot.writeFieldEnd()
    if self.split is not None:
      oprot.writeFieldBegin('split', TType.BOOL, 6)
      oprot.writeBool(self.split)
      oprot.writeFieldEnd()
    if self.replicaId is not None:
      oprot.writeFieldBegin('replicaId', TType.I32, 7)
      oprot.writeI32(self.replicaId)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    if self.regionId is None:
      raise TProtocol.TProtocolException(message='Required field regionId is unset!')
    if self.tableName is None:
      raise TProtocol.TProtocolException(message='Required field tableName is unset!')
    return

  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.regionId)
    value = (value * 31) ^ hash(self.tableName)
    value = (value * 31) ^ hash(self.startKey)
    value = (value * 31) ^ hash(self.endKey)
    value = (value * 31) ^ hash(self.offline)
    value = (value * 31) ^ hash(self.split)
    value = (value * 31) ^ hash(self.replicaId)
    return value

  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 TServerName:
  """
  Attributes:
   - hostName
   - port
   - startCode
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'hostName', None, None, ), # 1
    (2, TType.I32, 'port', None, None, ), # 2
    (3, TType.I64, 'startCode', None, None, ), # 3
  )

  def __init__(self, hostName=None, port=None, startCode=None,):
    self.hostName = hostName
    self.port = port
    self.startCode = startCode

  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.STRING:
          self.hostName = iprot.readString()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I32:
          self.port = iprot.readI32()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.startCode = 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('TServerName')
    if self.hostName is not None:
      oprot.writeFieldBegin('hostName', TType.STRING, 1)
      oprot.writeString(self.hostName)
      oprot.writeFieldEnd()
    if self.port is not None:
      oprot.writeFieldBegin('port', TType.I32, 2)
      oprot.writeI32(self.port)
      oprot.writeFieldEnd()
    if self.startCode is not None:
      oprot.writeFieldBegin('startCode', TType.I64, 3)
      oprot.writeI64(self.startCode)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    if self.hostName is None:
      raise TProtocol.TProtocolException(message='Required field hostName is unset!')
    return

  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.hostName)
    value = (value * 31) ^ hash(self.port)
    value = (value * 31) ^ hash(self.startCode)
    return value

  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 THRegionLocation:
  """
  Attributes:
   - serverName
   - regionInfo
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'serverName', (TServerName, TServerName.thrift_spec), None, ), # 1
    (2, TType.STRUCT, 'regionInfo', (THRegionInfo, THRegionInfo.thrift_spec), None, ), # 2
  )

  def __init__(self, serverName=None, regionInfo=None,):
    self.serverName = serverName
    self.regionInfo = regionInfo

  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.STRUCT:
          self.serverName = TServerName()
          self.serverName.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.regionInfo = THRegionInfo()
          self.regionInfo.read(iprot)
        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('THRegionLocation')
    if self.serverName is not None:
      oprot.writeFieldBegin('serverName', TType.STRUCT, 1)
      self.serverName.write(oprot)
      oprot.writeFieldEnd()
    if self.regionInfo is not None:
      oprot.writeFieldBegin('regionInfo', TType.STRUCT, 2)
      self.regionInfo.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    if self.serverName is None:
      raise TProtocol.TProtocolException(message='Required field serverName is unset!')
    if self.regionInfo is None:
      raise TProtocol.TProtocolException(message='Required field regionInfo is unset!')
    return

  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.serverName)
    value = (value * 31) ^ hash(self.regionInfo)
    return value

  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 TIOError(TException):
  """
  A TIOError exception signals that an error occurred communicating
  to the HBase master or a HBase region server. Also used to return
  more general HBase error conditions.

  Attributes:
   - message
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'message', None, None, ), # 1
  )

  def __init__(self, message=None,):
    self.message = message

  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.STRING:
          self.message = iprot.readString()
        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('TIOError')
    if self.message is not None:
      oprot.writeFieldBegin('message', TType.STRING, 1)
      oprot.writeString(self.message)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return

  def __str__(self):
    return repr(self)

  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.message)
    return value

  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 TIllegalArgument(TException):
  """
  A TIllegalArgument exception indicates an illegal or invalid
  argument was passed into a procedure.

  Attributes:
   - message
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'message', None, None, ), # 1
  )

  def __init__(self, message=None,):
    self.message = message

  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.STRING:
          self.message = iprot.readString()
        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('TIllegalArgument')
    if self.message is not None:
      oprot.writeFieldBegin('message', TType.STRING, 1)
      oprot.writeString(self.message)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return

  def __str__(self):
    return repr(self)

  def __hash__(self):
    value = 17
    value = (value * 31) ^ hash(self.message)
    return value

  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)

redpajama_set_name: RedPajamaGithub


When you comment on an article or a contribution, we collect your personal data (name, email address, comment text) only in the scope provided by you. The processing serves to allow you to comment and to display comments. By submitting the comment you agree to the processing of the transmitted data. The processing will be carried out on the basis of art. 6 (1) lit. a GDPR with your consent. You can withdraw your consent at any time by contacting us without affecting the legality of the processing carried out with your consent up to the withdrawal. Your personal data will then be deleted.


text:
Plymouth Art Weekender
Pick Up a Magazine
Eva Szwarc talks about the latest Pop Up exhibition at Ocean Studios
Plymouth is a place continuing to flourish with creativity, with an ever-growing artistic community. This cultural momentum can be witnessed in the events happening across the city, such as the Pop-Up exhibitions taking place at Ocean Studios across April. Each Week, a collective of artists independently take over the gallery, transforming the space with a different show. Currently on the last week, the final Pop-Up exhibition – Here and Now – showcases graduates from Plymouth University: Carly Seller, Fi Smart, Paige Barnard, Joe Allen and Kieran Walsh. All based at Ocean Studios, the artists are coming to the end of a year-long awarded residencies and have brought together their work created within the studios.
Although brought together as graduate tenants, their work complements each other collectively. They share a quiet colour palette, which works harmoniously with the exposed walls and stone riddled floor of the gallery space. At the same time, however, the work is quite diverse and ranges from ceramics and photography to painting. Joe Allen and Kieran Walksh both lend themselves to a playful and instinctive style. Allen turns every-day encounters in to heavily textured paintings, formed through repeatedly building up and scraping back layers of paint. He shares a studio with Walsh, whose drawings and ink paintings distill perceived landscapes into minimal and abstract forms. Carly Seller is a photographer whose experimental processes create enigmatic and haze-dream images, inspired by the circular symbol of the sun. The abstract outcomes contrast with the ceramic and print-work of Fi Smart, an artist who creates detailed stories through her work. Smart's bowl in the exhibition teems with musicians and colourful characters, inspired by Port Eliot Festival. Somewhat similar to Grayson Perry, her work unfolds beautiful narratives that entice the viewer to look closer. Also working with ceramics is Paige Bernard, an artist who is interested in socially engaging her audience as participators. Her ceramics, each unique with a handmade glaze, invite the viewer to touch, hold and even take.
Such a range of work by local artists affirms the cultural momentum that is making Plymouth glow. It makes the exhibition's title all the more apt: these are artists creating now in the city here. Be sure to visit 'Here and Now' during Ocean Studios' opening hours, 12-5pm each day until Sunday.
Photo Credit Eva Szwarc

redpajama_set_name: RedPajamaCommonCrawl


text:
Current affairsNews
Karachi International Airport under terrorist attack
Eoin O'Sullivan-Harris
During the night terrorists carrying guns and grenades have infiltrated Karachi Airport, killing several members of security and threatening further fatalities.
The group, of around eight or ten in size, entered Jinnah International Airport in Karachi late on Sunday evening. It is thought that certain members may have infiltrated the grounds through the Fokker gate area by cutting through barbed wire, while others may have used explosives to destroy a wall near the cargo area.
Eighteen deaths are reported so far, including seven members of the Airport Security Force (ASF). In addition, seven attackers have also been killed in the violence, at least one of whom was a suicide bomber. At least 14 others have been wounded.
In the midst of continuous heavy gun-fire exchanges between the militants and armed forces, large explosions have been observed by both journalists and passengers at the scene. Officials say that no planes have been damaged, despite several suggestions that one plane had earlier caught fire. Other reports indicated plumes of smoke rising from the old terminal building where the siege is taking place.
In response to the attacks, security forces have sealed off the perimeters of the airport, and the army has since been called in to combat the insurgents and ensure the security of those passengers left stranded in airplanes on the runways. Flights to the airport have subsequently been diverted elsewhere, and all operations at the airport have been indefinitely suspended.
As of yet, the identity of those responsible is unknown, and no precise motivation or objective has been made clear. However, according to recent reports in the Washington Post: "One senior Pakistani intelligence official, who spoke on the condition of anonymity to discuss the sensitive matter, said some of the militants tried to hijack a plane but were unsuccessful."
As things currently stand, there remains a group of three or four militants occupying the old terminal building, where fighting continues. However, the main building, which hosts the vast majority of commercial flights, is apparently secure.
Elsewhere in Pakistan tonight, 22 people are reported to have been killed and others injured in simultaneous suicide attacks close to the Pakistan-Iran border. Again, no group has yet accepted responsibility for these attacks.
Tonight's events offer grave insights into the delicate state of safety and security in Pakistan, particularly Karachi, where earlier this week sporadic outbreaks of violence, following the arrest in London of Altaf Hussain, leader of the Pakistan's MQM party, left citizens fearing for their lives. In recent years, Karachi has experienced increasing violence of this type, fuelled by an influx of migrants from the north-western regions of the country, where the Taliban influence is particularly strong.
Related Itemskarachipakistanterrorist attack
More in Current Affairs
Women of Ireland have rolled over for long enough: The 8th and the long walk to abortion rights
Emma Kiely
Changes to expect during menopause
The editorial unit
Why Equity Linked Savings Schemes is a preferred tax saving?
How the world's top designers would rebrand political parties
Royal baby furore: Proof that the British monarchy is still popular?
World Mental Health Day 2018: Raising awareness and combating stigma
Seven political personalities you should know about
Donald Trump: An enemy of the arts?
Trump's fortune: Where did the money come from?
A good night's sleep improves learning and memory finds research
UK children in poverty to reach 3.5m by 2020


Anytime on your own are building in direction of engage in a on line casino sport it is substantial towards understand and fully grasp the sport. Whether or not yourself are actively playing on the net or inside of a land primarily based on line casino it is the identical. Slot is a activity wherever your self engage in the match upon a unit referred to as slot product. Your self consist of toward place the cash inside and pull the arm within just a land on line casino or click on the button on the net. Though the similar photographs line up upon the reels or on your own order a distinctive demonstrate on your own purchase a earn. This is the simple match. There are amount of Reasons and dissimilarities in direction of check out and encounter of every is fairly crucial in direction of crank out a gain inside on-line slot match.
What by yourself need to have towards understand for on the internet slot video game is the payoff desk. Yourself might adhere to that with reduced bets yourself can sometimes attain maximum payouts. The major issue for oneself in the direction of choose is that which match of slot on your own require in the direction of enjoy and what style of revenue your self are prepared towards guess. At the time oneself are intrigued in the direction of guess substantial funds within slot activity your self can decide on the ground breaking. In the direction of wager a smaller sized quantity by yourself need to come across a sport which does not have to have your self in the direction of wager superior volume in the direction of rating a acquire. It is for your self towards choose intently what type of slot video game on your own have to have in the direction of participate in in opposition to the solutions readily available and the funds at your disposal.
The popular slot activity that by yourself will arrive throughout is known as multipliers. They consist of payout centered upon symbols and other people primarily based upon cash. Oneself could possibly perform them for one coin and no penalty will be billed. If yourself are creating toward engage in with solitary coin then this is the excellent recreation in direction of enjoy on line. Yet another design of slot that oneself will appear throughout is reward multiplier. Below your self can employ a number of quantities of cash. Inside of this difference on your own will get hold of a reward once your self retain the services of utmost variety of cash and strike a jackpot.
The utmost vital final decision which requirements in the direction of be created When participating in reward multiplier is that no matter whether in the direction of employ range of cash. The in addition aspect of working with further more than just one coin is that on your own could strike the jackpot and get a massive total of economical as the jackpots are modern.
The on-line slot devices are hundred % harmless. There is no scope of dishonest as they are making use of Random Amount Generator which retains doing work constantly. The avid gamers include great deal of options aside towards reward multipliers which include conditional bets and other extra bonuses.


If you are looking for a wedding make up artist in Aix en Provence, Amandine is at your disposal.
Following an eclectic artistic career as a comedian, musician, author and composer singer, Amandine naturally turned to stage makeup. She enriched her curriculum as a makeup artist with the brand l'Atelier International de maquillage and famous makeup artists such as Vincent De Monfreid and Hélène Quillet ; she intervenes on TV and fashion shows and has a more artistic orientation in her personal projects.
Back in the South where she was born, she offers her expertise to brides-to-be.
Amandine, a makeup artist settled in Aix-en-Provence, intervenes for your trial and on your wedding day around Aix-en-Provence, Avignon and Montpellier.
She will propose a makeup based on your personality, your hairstyle and your expectations. She uses long-lasting high quality professional products.
Amandine will also be able to look after a few guests during the preparations. If there are too many guests to be pampered, we can send out a second makeup artist, as well as one or several hairstylists, should you require this service also.
You are looking for advice on your makeup for your wedding ? Amandine regularly shares tips and advice on our blog.
For more information about our hair and makeup services, you can check our dedicated web page. To find out about availability or for any price request, please contact us.


text:
HomeForeign PolicyTrump Says Trade Deal with UK has Unlimited Potential
Trump Says Trade Deal with UK has Unlimited Potential
March 14, 2019 Focus Washington Foreign Policy
On Thursday, President Donald Trump stated that Washington is looking forward to negotiating a large scale trade agreement with the United Kingdom, adding that the agreement would have "unlimited" potential.
"My Administration looks forward to negotiating a large scale Trade Deal with the United Kingdom. The potential is unlimited!" Trump tweeted.
According to Fox News, the tweet comes one day after the U.K. Parliament voted against the possibility of leaving the European Union (EU) without an exit agreement.
If the U.K. does ultimately leave the EU, it will force the country to negotiate its own individual trade deals with the U.S. and other countries.
Wednesday's vote doesn't eliminate the possibility that U.K. will leave the EU, but it does open the door to a delay of that departure. U.K. is scheduled to leave the EU on March 29, but a vote Thursday might delay the move.
The U.S. Trade Representative's office has indicated it plans to negotiate a trade agreement with the U.K. after it leaves the European bloc.
"We intend to initiate negotiations with the United Kingdom as soon as it is ready after it exits from the European Union on March 29," U.S. Trade Representative Robert Lighthizer said in a letter to Congress last year.
Beto O'Rourke to Seek 2020 Democratic Presidential Nomination
Andrew Weissmann Is Leaving Mueller's Team: Report


EIMI Dry Shampoo is the BEST Dry Shampoo on the market, Yes REALLY!!
Wella have recently launched an exciting new product line like no other they've launched before. EIMIenables you to mix things up and get individual results!
The packaging is modern and fresh with cool names that are self explainitrty, each product is cleverly grouped under which finish you want and level of hold so it's so easy to pick out what you need!
Here are the groups: Volume, Smooth, Texture, Shine, Fixing (hairsprays) On each product there are 4 little circles at the the top, the coloured in circle indicate the level of hold 1 being less and 4 being most, it's that easy.
So I'm testing EIMI DRY ME a level 1 hold dry shampoo which obsorbs unwanted oil and adds a little va va voom in a matte finish. You simply shake me, spray me, style me, use it on dry hair and brush through.


text:
Kaleidoscope Music Memes
Kaleidoscope Music Memes: Luke Daniels & Rihab Azar
The Atkinson, Foyer
Free Event.
Events next 7 days
Award winning and critically acclaimed folk musician and singer Luke Daniels hosts Kaleidoscope Music Memes – a series of four folk and world music concerts showcasing three world-class performers from Syria, China and South Africa in duo concerts that will culminate in a final full quartet performance.
Luke Daniels & Abel Selacoe
Wed 8 May, 1pm, Free
Luke Daniels & Rihab Azar
Wed 22 May, 1pm, Free
Luke Daniels & Shu Jiang
Thu 13 Jun, 1pm, Free
Full Quartet
Wed 26 Jun, 7:30pm, £14/£12
In an exciting project with The Atkinson, Met Bury, Royal Liverpool Philharmonic and the Citadel St Helens, these concerts will also use digital technology to allow audiences to jointly create new music in the run up to each concert. Create and share your own musical arrangements on social media and with the artists through the MusicMeme mobile app – free to all concert attenders!
Enjoy outstanding music and be part of the creative process with this unique series of concerts.
Abel Selaocoe is a South African cellist who collaborates with beatboxers and world musicians and performs solo classical recitals and concerto performances as a soloist with numerous orchestras including Kwa-Zulu Philharmonic, Johnannesburg Phil and Randburg Symphony.
Rihab Azar is from the Syrian city of Homs. She studied at the Conservatoire of Damascus under such masters as Askar Ali Akbar and Issam Rafea. In 2014, She became the first woman oudist to perform accompanied by the Syrian National Orchestra for Arabic Music. Since moving to the UK in 2016 under the Migrant Talent Scheme, she has performed with the London Sinfonietta and at St. Paul's Cathedral.
Shu Jiang is an ethnomusicologist and expert player of Chinese zithers (zheng and qin) with a special interest in the music of China. She has a particular interest in cross cultural exchange of East Asian music in the context of Western music and works alongside a range of composers and world musicians in the UK.
Luke Daniels is a multi- instrumentalist specialising in button accordion and melodeon and has enjoyed a long career collaborating with a range of artists and organisations as a means of promoting folk music.
www.lukedanielsmusic.com
+ View Google map
Lord Street - Southport
+ What's on today
Thursday 9 January 2020 - Sunday 19 January 2020
Aladdin Pantomime
Times vary The Atkinson – Theatre
Love Folk Festival
Times vary The Atkinson – Studio Clubstyle
Sheelanagig
7:15 pm - 10:45 pm The Atkinson – Studio Clubstyle
Lucy Farrell and Andrew Waite
12:30 pm - 1:30 pm The Atkinson – Studio Clubstyle
Granny's Attic
2:15 pm - 3:15 pm The Atkinson – Studio Clubstyle
Blair Dunlop
Merry Hell
Martyn Joseph
The Bon Jovi Experience
7:30 pm - 10:00 pm The Atkinson – Theatre


With an experience of more than 10 years in co-manufacturing as well as outsourcing food R&D ('contract research'), we have an overview of possible EU partners, technical benchmarking, technical evaluation and audits and problem solving. The professionality of our services allow company managers to focus on core activities, while keeping well informed and full control outsourced projects. Our services can be contracted flexibly, adjusting to client needs. Ad-hoc or interim basis are possible. Our experience helps avoiding outsourcing pitfalls and getting to the needed results with less resources.
Contract manufacturing services cover food processing, co-packing as well as ingredient co-manufacturing. Although we work only for food applications, the technologies we have worked with go far beyond food technologies into: pharma, chemical and physical technologies. In the application to foods, a set of specific food regulatory requirements must be checked. We work in technical compliance to make sure that the end-result can be applied to foods. Projects may involve manufacturing a complete product or only certain unit operations (processing steps), the production of samples, manufacturing tests, or other.
Responsible for contract manufacturing projects is Dr.-Ing. Kuhn, c.kuhn@foodlinkforum.com.
Exploration of new technologies or outsourcing of non-core activities motivate external research contracting. In certain cases certified European laboratories must be used, as in the case of regulatory compliance. In other cases, a specific technology for a unit operation must be used. Besides the usual outsourcing steps, outsourcing R&D has some peculiarities which make it tricky and difficult. Our many years of experience in helping companies deal with outsourcing R&D has proven a valuable asset for our clients to avoid pitfalls. We know many R&D partners in Europe, and what their strenghts are. We help companies find the appropriate partner for their question, contracting and managing the project. how they workOur services cover the whole traject of outsourcing, partner search, benchmarking and evaluation.