You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hbase.apache.org by st...@apache.org on 2012/11/06 22:22:30 UTC

svn commit: r1406339 [14/17] - in /hbase/trunk: ./ examples/ hbase-examples/ hbase-examples/src/ hbase-examples/src/main/ hbase-examples/src/main/cpp/ hbase-examples/src/main/cpp/gen-cpp/ hbase-examples/src/main/java/ hbase-examples/src/main/java/org/ ...

Added: hbase/trunk/hbase-examples/src/main/python/gen-py/hbase/Hbase.py
URL: http://svn.apache.org/viewvc/hbase/trunk/hbase-examples/src/main/python/gen-py/hbase/Hbase.py?rev=1406339&view=auto
==============================================================================
--- hbase/trunk/hbase-examples/src/main/python/gen-py/hbase/Hbase.py (added)
+++ hbase/trunk/hbase-examples/src/main/python/gen-py/hbase/Hbase.py Tue Nov  6 21:22:27 2012
@@ -0,0 +1,10286 @@
+#
+# Autogenerated by Thrift Compiler (0.9.0)
+#
+# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+#
+#  options string: py
+#
+
+from thrift.Thrift import TType, TMessageType, TException, TApplicationException
+from ttypes import *
+from thrift.Thrift import TProcessor
+from thrift.transport import TTransport
+from thrift.protocol import TBinaryProtocol, TProtocol
+try:
+  from thrift.protocol import fastbinary
+except:
+  fastbinary = None
+
+
+class Iface:
+  def enableTable(self, tableName):
+    """
+    Brings a table on-line (enables it)
+
+    Parameters:
+     - tableName: name of the table
+    """
+    pass
+
+  def disableTable(self, tableName):
+    """
+    Disables a table (takes it off-line) If it is being served, the master
+    will tell the servers to stop serving it.
+
+    Parameters:
+     - tableName: name of the table
+    """
+    pass
+
+  def isTableEnabled(self, tableName):
+    """
+    @return true if table is on-line
+
+    Parameters:
+     - tableName: name of the table to check
+    """
+    pass
+
+  def compact(self, tableNameOrRegionName):
+    """
+    Parameters:
+     - tableNameOrRegionName
+    """
+    pass
+
+  def majorCompact(self, tableNameOrRegionName):
+    """
+    Parameters:
+     - tableNameOrRegionName
+    """
+    pass
+
+  def getTableNames(self, ):
+    """
+    List all the userspace tables.
+
+    @return returns a list of names
+    """
+    pass
+
+  def getColumnDescriptors(self, tableName):
+    """
+    List all the column families assoicated with a table.
+
+    @return list of column family descriptors
+
+    Parameters:
+     - tableName: table name
+    """
+    pass
+
+  def getTableRegions(self, tableName):
+    """
+    List the regions associated with a table.
+
+    @return list of region descriptors
+
+    Parameters:
+     - tableName: table name
+    """
+    pass
+
+  def createTable(self, tableName, columnFamilies):
+    """
+    Create a table with the specified column families.  The name
+    field for each ColumnDescriptor must be set and must end in a
+    colon (:). All other fields are optional and will get default
+    values if not explicitly specified.
+
+    @throws IllegalArgument if an input parameter is invalid
+
+    @throws AlreadyExists if the table name already exists
+
+    Parameters:
+     - tableName: name of table to create
+     - columnFamilies: list of column family descriptors
+    """
+    pass
+
+  def deleteTable(self, tableName):
+    """
+    Deletes a table
+
+    @throws IOError if table doesn't exist on server or there was some other
+    problem
+
+    Parameters:
+     - tableName: name of table to delete
+    """
+    pass
+
+  def get(self, tableName, row, column, attributes):
+    """
+    Get a single TCell for the specified table, row, and column at the
+    latest timestamp. Returns an empty list if no such value exists.
+
+    @return value for specified row/column
+
+    Parameters:
+     - tableName: name of table
+     - row: row key
+     - column: column name
+     - attributes: Get attributes
+    """
+    pass
+
+  def getVer(self, tableName, row, column, numVersions, attributes):
+    """
+    Get the specified number of versions for the specified table,
+    row, and column.
+
+    @return list of cells for specified row/column
+
+    Parameters:
+     - tableName: name of table
+     - row: row key
+     - column: column name
+     - numVersions: number of versions to retrieve
+     - attributes: Get attributes
+    """
+    pass
+
+  def getVerTs(self, tableName, row, column, timestamp, numVersions, attributes):
+    """
+    Get the specified number of versions for the specified table,
+    row, and column.  Only versions less than or equal to the specified
+    timestamp will be returned.
+
+    @return list of cells for specified row/column
+
+    Parameters:
+     - tableName: name of table
+     - row: row key
+     - column: column name
+     - timestamp: timestamp
+     - numVersions: number of versions to retrieve
+     - attributes: Get attributes
+    """
+    pass
+
+  def getRow(self, tableName, row, attributes):
+    """
+    Get all the data for the specified table and row at the latest
+    timestamp. Returns an empty list if the row does not exist.
+
+    @return TRowResult containing the row and map of columns to TCells
+
+    Parameters:
+     - tableName: name of table
+     - row: row key
+     - attributes: Get attributes
+    """
+    pass
+
+  def getRowWithColumns(self, tableName, row, columns, attributes):
+    """
+    Get the specified columns for the specified table and row at the latest
+    timestamp. Returns an empty list if the row does not exist.
+
+    @return TRowResult containing the row and map of columns to TCells
+
+    Parameters:
+     - tableName: name of table
+     - row: row key
+     - columns: List of columns to return, null for all columns
+     - attributes: Get attributes
+    """
+    pass
+
+  def getRowTs(self, tableName, row, timestamp, attributes):
+    """
+    Get all the data for the specified table and row at the specified
+    timestamp. Returns an empty list if the row does not exist.
+
+    @return TRowResult containing the row and map of columns to TCells
+
+    Parameters:
+     - tableName: name of the table
+     - row: row key
+     - timestamp: timestamp
+     - attributes: Get attributes
+    """
+    pass
+
+  def getRowWithColumnsTs(self, tableName, row, columns, timestamp, attributes):
+    """
+    Get the specified columns for the specified table and row at the specified
+    timestamp. Returns an empty list if the row does not exist.
+
+    @return TRowResult containing the row and map of columns to TCells
+
+    Parameters:
+     - tableName: name of table
+     - row: row key
+     - columns: List of columns to return, null for all columns
+     - timestamp
+     - attributes: Get attributes
+    """
+    pass
+
+  def getRows(self, tableName, rows, attributes):
+    """
+    Get all the data for the specified table and rows at the latest
+    timestamp. Returns an empty list if no rows exist.
+
+    @return TRowResult containing the rows and map of columns to TCells
+
+    Parameters:
+     - tableName: name of table
+     - rows: row keys
+     - attributes: Get attributes
+    """
+    pass
+
+  def getRowsWithColumns(self, tableName, rows, columns, attributes):
+    """
+    Get the specified columns for the specified table and rows at the latest
+    timestamp. Returns an empty list if no rows exist.
+
+    @return TRowResult containing the rows and map of columns to TCells
+
+    Parameters:
+     - tableName: name of table
+     - rows: row keys
+     - columns: List of columns to return, null for all columns
+     - attributes: Get attributes
+    """
+    pass
+
+  def getRowsTs(self, tableName, rows, timestamp, attributes):
+    """
+    Get all the data for the specified table and rows at the specified
+    timestamp. Returns an empty list if no rows exist.
+
+    @return TRowResult containing the rows and map of columns to TCells
+
+    Parameters:
+     - tableName: name of the table
+     - rows: row keys
+     - timestamp: timestamp
+     - attributes: Get attributes
+    """
+    pass
+
+  def getRowsWithColumnsTs(self, tableName, rows, columns, timestamp, attributes):
+    """
+    Get the specified columns for the specified table and rows at the specified
+    timestamp. Returns an empty list if no rows exist.
+
+    @return TRowResult containing the rows and map of columns to TCells
+
+    Parameters:
+     - tableName: name of table
+     - rows: row keys
+     - columns: List of columns to return, null for all columns
+     - timestamp
+     - attributes: Get attributes
+    """
+    pass
+
+  def mutateRow(self, tableName, row, mutations, attributes):
+    """
+    Apply a series of mutations (updates/deletes) to a row in a
+    single transaction.  If an exception is thrown, then the
+    transaction is aborted.  Default current timestamp is used, and
+    all entries will have an identical timestamp.
+
+    Parameters:
+     - tableName: name of table
+     - row: row key
+     - mutations: list of mutation commands
+     - attributes: Mutation attributes
+    """
+    pass
+
+  def mutateRowTs(self, tableName, row, mutations, timestamp, attributes):
+    """
+    Apply a series of mutations (updates/deletes) to a row in a
+    single transaction.  If an exception is thrown, then the
+    transaction is aborted.  The specified timestamp is used, and
+    all entries will have an identical timestamp.
+
+    Parameters:
+     - tableName: name of table
+     - row: row key
+     - mutations: list of mutation commands
+     - timestamp: timestamp
+     - attributes: Mutation attributes
+    """
+    pass
+
+  def mutateRows(self, tableName, rowBatches, attributes):
+    """
+    Apply a series of batches (each a series of mutations on a single row)
+    in a single transaction.  If an exception is thrown, then the
+    transaction is aborted.  Default current timestamp is used, and
+    all entries will have an identical timestamp.
+
+    Parameters:
+     - tableName: name of table
+     - rowBatches: list of row batches
+     - attributes: Mutation attributes
+    """
+    pass
+
+  def mutateRowsTs(self, tableName, rowBatches, timestamp, attributes):
+    """
+    Apply a series of batches (each a series of mutations on a single row)
+    in a single transaction.  If an exception is thrown, then the
+    transaction is aborted.  The specified timestamp is used, and
+    all entries will have an identical timestamp.
+
+    Parameters:
+     - tableName: name of table
+     - rowBatches: list of row batches
+     - timestamp: timestamp
+     - attributes: Mutation attributes
+    """
+    pass
+
+  def atomicIncrement(self, tableName, row, column, value):
+    """
+    Atomically increment the column value specified.  Returns the next value post increment.
+
+    Parameters:
+     - tableName: name of table
+     - row: row to increment
+     - column: name of column
+     - value: amount to increment by
+    """
+    pass
+
+  def deleteAll(self, tableName, row, column, attributes):
+    """
+    Delete all cells that match the passed row and column.
+
+    Parameters:
+     - tableName: name of table
+     - row: Row to update
+     - column: name of column whose value is to be deleted
+     - attributes: Delete attributes
+    """
+    pass
+
+  def deleteAllTs(self, tableName, row, column, timestamp, attributes):
+    """
+    Delete all cells that match the passed row and column and whose
+    timestamp is equal-to or older than the passed timestamp.
+
+    Parameters:
+     - tableName: name of table
+     - row: Row to update
+     - column: name of column whose value is to be deleted
+     - timestamp: timestamp
+     - attributes: Delete attributes
+    """
+    pass
+
+  def deleteAllRow(self, tableName, row, attributes):
+    """
+    Completely delete the row's cells.
+
+    Parameters:
+     - tableName: name of table
+     - row: key of the row to be completely deleted.
+     - attributes: Delete attributes
+    """
+    pass
+
+  def increment(self, increment):
+    """
+    Increment a cell by the ammount.
+    Increments can be applied async if hbase.regionserver.thrift.coalesceIncrement is set to true.
+    False is the default.  Turn to true if you need the extra performance and can accept some
+    data loss if a thrift server dies with increments still in the queue.
+
+    Parameters:
+     - increment: The single increment to apply
+    """
+    pass
+
+  def incrementRows(self, increments):
+    """
+    Parameters:
+     - increments: The list of increments
+    """
+    pass
+
+  def deleteAllRowTs(self, tableName, row, timestamp, attributes):
+    """
+    Completely delete the row's cells marked with a timestamp
+    equal-to or older than the passed timestamp.
+
+    Parameters:
+     - tableName: name of table
+     - row: key of the row to be completely deleted.
+     - timestamp: timestamp
+     - attributes: Delete attributes
+    """
+    pass
+
+  def scannerOpenWithScan(self, tableName, scan, attributes):
+    """
+    Get a scanner on the current table, using the Scan instance
+    for the scan parameters.
+
+    Parameters:
+     - tableName: name of table
+     - scan: Scan instance
+     - attributes: Scan attributes
+    """
+    pass
+
+  def scannerOpen(self, tableName, startRow, columns, attributes):
+    """
+    Get a scanner on the current table starting at the specified row and
+    ending at the last row in the table.  Return the specified columns.
+
+    @return scanner id to be used with other scanner procedures
+
+    Parameters:
+     - tableName: name of table
+     - startRow: Starting row in table to scan.
+    Send "" (empty string) to start at the first row.
+     - columns: columns to scan. If column name is a column family, all
+    columns of the specified column family are returned. It's also possible
+    to pass a regex in the column qualifier.
+     - attributes: Scan attributes
+    """
+    pass
+
+  def scannerOpenWithStop(self, tableName, startRow, stopRow, columns, attributes):
+    """
+    Get a scanner on the current table starting and stopping at the
+    specified rows.  ending at the last row in the table.  Return the
+    specified columns.
+
+    @return scanner id to be used with other scanner procedures
+
+    Parameters:
+     - tableName: name of table
+     - startRow: Starting row in table to scan.
+    Send "" (empty string) to start at the first row.
+     - stopRow: row to stop scanning on. This row is *not* included in the
+    scanner's results
+     - columns: columns to scan. If column name is a column family, all
+    columns of the specified column family are returned. It's also possible
+    to pass a regex in the column qualifier.
+     - attributes: Scan attributes
+    """
+    pass
+
+  def scannerOpenWithPrefix(self, tableName, startAndPrefix, columns, attributes):
+    """
+    Open a scanner for a given prefix.  That is all rows will have the specified
+    prefix. No other rows will be returned.
+
+    @return scanner id to use with other scanner calls
+
+    Parameters:
+     - tableName: name of table
+     - startAndPrefix: the prefix (and thus start row) of the keys you want
+     - columns: the columns you want returned
+     - attributes: Scan attributes
+    """
+    pass
+
+  def scannerOpenTs(self, tableName, startRow, columns, timestamp, attributes):
+    """
+    Get a scanner on the current table starting at the specified row and
+    ending at the last row in the table.  Return the specified columns.
+    Only values with the specified timestamp are returned.
+
+    @return scanner id to be used with other scanner procedures
+
+    Parameters:
+     - tableName: name of table
+     - startRow: Starting row in table to scan.
+    Send "" (empty string) to start at the first row.
+     - columns: columns to scan. If column name is a column family, all
+    columns of the specified column family are returned. It's also possible
+    to pass a regex in the column qualifier.
+     - timestamp: timestamp
+     - attributes: Scan attributes
+    """
+    pass
+
+  def scannerOpenWithStopTs(self, tableName, startRow, stopRow, columns, timestamp, attributes):
+    """
+    Get a scanner on the current table starting and stopping at the
+    specified rows.  ending at the last row in the table.  Return the
+    specified columns.  Only values with the specified timestamp are
+    returned.
+
+    @return scanner id to be used with other scanner procedures
+
+    Parameters:
+     - tableName: name of table
+     - startRow: Starting row in table to scan.
+    Send "" (empty string) to start at the first row.
+     - stopRow: row to stop scanning on. This row is *not* included in the
+    scanner's results
+     - columns: columns to scan. If column name is a column family, all
+    columns of the specified column family are returned. It's also possible
+    to pass a regex in the column qualifier.
+     - timestamp: timestamp
+     - attributes: Scan attributes
+    """
+    pass
+
+  def scannerGet(self, id):
+    """
+    Returns the scanner's current row value and advances to the next
+    row in the table.  When there are no more rows in the table, or a key
+    greater-than-or-equal-to the scanner's specified stopRow is reached,
+    an empty list is returned.
+
+    @return a TRowResult containing the current row and a map of the columns to TCells.
+
+    @throws IllegalArgument if ScannerID is invalid
+
+    @throws NotFound when the scanner reaches the end
+
+    Parameters:
+     - id: id of a scanner returned by scannerOpen
+    """
+    pass
+
+  def scannerGetList(self, id, nbRows):
+    """
+    Returns, starting at the scanner's current row value nbRows worth of
+    rows and advances to the next row in the table.  When there are no more
+    rows in the table, or a key greater-than-or-equal-to the scanner's
+    specified stopRow is reached,  an empty list is returned.
+
+    @return a TRowResult containing the current row and a map of the columns to TCells.
+
+    @throws IllegalArgument if ScannerID is invalid
+
+    @throws NotFound when the scanner reaches the end
+
+    Parameters:
+     - id: id of a scanner returned by scannerOpen
+     - nbRows: number of results to return
+    """
+    pass
+
+  def scannerClose(self, id):
+    """
+    Closes the server-state associated with an open scanner.
+
+    @throws IllegalArgument if ScannerID is invalid
+
+    Parameters:
+     - id: id of a scanner returned by scannerOpen
+    """
+    pass
+
+  def getRowOrBefore(self, tableName, row, family):
+    """
+    Get the row just before the specified one.
+
+    @return value for specified row/column
+
+    Parameters:
+     - tableName: name of table
+     - row: row key
+     - family: column name
+    """
+    pass
+
+  def getRegionInfo(self, row):
+    """
+    Get the regininfo for the specified row. It scans
+    the metatable to find region's start and end keys.
+
+    @return value for specified row/column
+
+    Parameters:
+     - row: row key
+    """
+    pass
+
+
+class Client(Iface):
+  def __init__(self, iprot, oprot=None):
+    self._iprot = self._oprot = iprot
+    if oprot is not None:
+      self._oprot = oprot
+    self._seqid = 0
+
+  def enableTable(self, tableName):
+    """
+    Brings a table on-line (enables it)
+
+    Parameters:
+     - tableName: name of the table
+    """
+    self.send_enableTable(tableName)
+    self.recv_enableTable()
+
+  def send_enableTable(self, tableName):
+    self._oprot.writeMessageBegin('enableTable', TMessageType.CALL, self._seqid)
+    args = enableTable_args()
+    args.tableName = tableName
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_enableTable(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = enableTable_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.io is not None:
+      raise result.io
+    return
+
+  def disableTable(self, tableName):
+    """
+    Disables a table (takes it off-line) If it is being served, the master
+    will tell the servers to stop serving it.
+
+    Parameters:
+     - tableName: name of the table
+    """
+    self.send_disableTable(tableName)
+    self.recv_disableTable()
+
+  def send_disableTable(self, tableName):
+    self._oprot.writeMessageBegin('disableTable', TMessageType.CALL, self._seqid)
+    args = disableTable_args()
+    args.tableName = tableName
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_disableTable(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = disableTable_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.io is not None:
+      raise result.io
+    return
+
+  def isTableEnabled(self, tableName):
+    """
+    @return true if table is on-line
+
+    Parameters:
+     - tableName: name of the table to check
+    """
+    self.send_isTableEnabled(tableName)
+    return self.recv_isTableEnabled()
+
+  def send_isTableEnabled(self, tableName):
+    self._oprot.writeMessageBegin('isTableEnabled', TMessageType.CALL, self._seqid)
+    args = isTableEnabled_args()
+    args.tableName = tableName
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_isTableEnabled(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = isTableEnabled_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.io is not None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "isTableEnabled failed: unknown result");
+
+  def compact(self, tableNameOrRegionName):
+    """
+    Parameters:
+     - tableNameOrRegionName
+    """
+    self.send_compact(tableNameOrRegionName)
+    self.recv_compact()
+
+  def send_compact(self, tableNameOrRegionName):
+    self._oprot.writeMessageBegin('compact', TMessageType.CALL, self._seqid)
+    args = compact_args()
+    args.tableNameOrRegionName = tableNameOrRegionName
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_compact(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = compact_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.io is not None:
+      raise result.io
+    return
+
+  def majorCompact(self, tableNameOrRegionName):
+    """
+    Parameters:
+     - tableNameOrRegionName
+    """
+    self.send_majorCompact(tableNameOrRegionName)
+    self.recv_majorCompact()
+
+  def send_majorCompact(self, tableNameOrRegionName):
+    self._oprot.writeMessageBegin('majorCompact', TMessageType.CALL, self._seqid)
+    args = majorCompact_args()
+    args.tableNameOrRegionName = tableNameOrRegionName
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_majorCompact(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = majorCompact_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.io is not None:
+      raise result.io
+    return
+
+  def getTableNames(self, ):
+    """
+    List all the userspace tables.
+
+    @return returns a list of names
+    """
+    self.send_getTableNames()
+    return self.recv_getTableNames()
+
+  def send_getTableNames(self, ):
+    self._oprot.writeMessageBegin('getTableNames', TMessageType.CALL, self._seqid)
+    args = getTableNames_args()
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_getTableNames(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getTableNames_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.io is not None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTableNames failed: unknown result");
+
+  def getColumnDescriptors(self, tableName):
+    """
+    List all the column families assoicated with a table.
+
+    @return list of column family descriptors
+
+    Parameters:
+     - tableName: table name
+    """
+    self.send_getColumnDescriptors(tableName)
+    return self.recv_getColumnDescriptors()
+
+  def send_getColumnDescriptors(self, tableName):
+    self._oprot.writeMessageBegin('getColumnDescriptors', TMessageType.CALL, self._seqid)
+    args = getColumnDescriptors_args()
+    args.tableName = tableName
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_getColumnDescriptors(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getColumnDescriptors_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.io is not None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getColumnDescriptors failed: unknown result");
+
+  def getTableRegions(self, tableName):
+    """
+    List the regions associated with a table.
+
+    @return list of region descriptors
+
+    Parameters:
+     - tableName: table name
+    """
+    self.send_getTableRegions(tableName)
+    return self.recv_getTableRegions()
+
+  def send_getTableRegions(self, tableName):
+    self._oprot.writeMessageBegin('getTableRegions', TMessageType.CALL, self._seqid)
+    args = getTableRegions_args()
+    args.tableName = tableName
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_getTableRegions(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getTableRegions_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.io is not None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTableRegions failed: unknown result");
+
+  def createTable(self, tableName, columnFamilies):
+    """
+    Create a table with the specified column families.  The name
+    field for each ColumnDescriptor must be set and must end in a
+    colon (:). All other fields are optional and will get default
+    values if not explicitly specified.
+
+    @throws IllegalArgument if an input parameter is invalid
+
+    @throws AlreadyExists if the table name already exists
+
+    Parameters:
+     - tableName: name of table to create
+     - columnFamilies: list of column family descriptors
+    """
+    self.send_createTable(tableName, columnFamilies)
+    self.recv_createTable()
+
+  def send_createTable(self, tableName, columnFamilies):
+    self._oprot.writeMessageBegin('createTable', TMessageType.CALL, self._seqid)
+    args = createTable_args()
+    args.tableName = tableName
+    args.columnFamilies = columnFamilies
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_createTable(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = createTable_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.io is not None:
+      raise result.io
+    if result.ia is not None:
+      raise result.ia
+    if result.exist is not None:
+      raise result.exist
+    return
+
+  def deleteTable(self, tableName):
+    """
+    Deletes a table
+
+    @throws IOError if table doesn't exist on server or there was some other
+    problem
+
+    Parameters:
+     - tableName: name of table to delete
+    """
+    self.send_deleteTable(tableName)
+    self.recv_deleteTable()
+
+  def send_deleteTable(self, tableName):
+    self._oprot.writeMessageBegin('deleteTable', TMessageType.CALL, self._seqid)
+    args = deleteTable_args()
+    args.tableName = tableName
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_deleteTable(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = deleteTable_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.io is not None:
+      raise result.io
+    return
+
+  def get(self, tableName, row, column, attributes):
+    """
+    Get a single TCell for the specified table, row, and column at the
+    latest timestamp. Returns an empty list if no such value exists.
+
+    @return value for specified row/column
+
+    Parameters:
+     - tableName: name of table
+     - row: row key
+     - column: column name
+     - attributes: Get attributes
+    """
+    self.send_get(tableName, row, column, attributes)
+    return self.recv_get()
+
+  def send_get(self, tableName, row, column, attributes):
+    self._oprot.writeMessageBegin('get', TMessageType.CALL, self._seqid)
+    args = get_args()
+    args.tableName = tableName
+    args.row = row
+    args.column = column
+    args.attributes = attributes
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_get(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = get_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.io is not None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "get failed: unknown result");
+
+  def getVer(self, tableName, row, column, numVersions, attributes):
+    """
+    Get the specified number of versions for the specified table,
+    row, and column.
+
+    @return list of cells for specified row/column
+
+    Parameters:
+     - tableName: name of table
+     - row: row key
+     - column: column name
+     - numVersions: number of versions to retrieve
+     - attributes: Get attributes
+    """
+    self.send_getVer(tableName, row, column, numVersions, attributes)
+    return self.recv_getVer()
+
+  def send_getVer(self, tableName, row, column, numVersions, attributes):
+    self._oprot.writeMessageBegin('getVer', TMessageType.CALL, self._seqid)
+    args = getVer_args()
+    args.tableName = tableName
+    args.row = row
+    args.column = column
+    args.numVersions = numVersions
+    args.attributes = attributes
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_getVer(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getVer_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.io is not None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVer failed: unknown result");
+
+  def getVerTs(self, tableName, row, column, timestamp, numVersions, attributes):
+    """
+    Get the specified number of versions for the specified table,
+    row, and column.  Only versions less than or equal to the specified
+    timestamp will be returned.
+
+    @return list of cells for specified row/column
+
+    Parameters:
+     - tableName: name of table
+     - row: row key
+     - column: column name
+     - timestamp: timestamp
+     - numVersions: number of versions to retrieve
+     - attributes: Get attributes
+    """
+    self.send_getVerTs(tableName, row, column, timestamp, numVersions, attributes)
+    return self.recv_getVerTs()
+
+  def send_getVerTs(self, tableName, row, column, timestamp, numVersions, attributes):
+    self._oprot.writeMessageBegin('getVerTs', TMessageType.CALL, self._seqid)
+    args = getVerTs_args()
+    args.tableName = tableName
+    args.row = row
+    args.column = column
+    args.timestamp = timestamp
+    args.numVersions = numVersions
+    args.attributes = attributes
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_getVerTs(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getVerTs_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.io is not None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVerTs failed: unknown result");
+
+  def getRow(self, tableName, row, attributes):
+    """
+    Get all the data for the specified table and row at the latest
+    timestamp. Returns an empty list if the row does not exist.
+
+    @return TRowResult containing the row and map of columns to TCells
+
+    Parameters:
+     - tableName: name of table
+     - row: row key
+     - attributes: Get attributes
+    """
+    self.send_getRow(tableName, row, attributes)
+    return self.recv_getRow()
+
+  def send_getRow(self, tableName, row, attributes):
+    self._oprot.writeMessageBegin('getRow', TMessageType.CALL, self._seqid)
+    args = getRow_args()
+    args.tableName = tableName
+    args.row = row
+    args.attributes = attributes
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_getRow(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getRow_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.io is not None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRow failed: unknown result");
+
+  def getRowWithColumns(self, tableName, row, columns, attributes):
+    """
+    Get the specified columns for the specified table and row at the latest
+    timestamp. Returns an empty list if the row does not exist.
+
+    @return TRowResult containing the row and map of columns to TCells
+
+    Parameters:
+     - tableName: name of table
+     - row: row key
+     - columns: List of columns to return, null for all columns
+     - attributes: Get attributes
+    """
+    self.send_getRowWithColumns(tableName, row, columns, attributes)
+    return self.recv_getRowWithColumns()
+
+  def send_getRowWithColumns(self, tableName, row, columns, attributes):
+    self._oprot.writeMessageBegin('getRowWithColumns', TMessageType.CALL, self._seqid)
+    args = getRowWithColumns_args()
+    args.tableName = tableName
+    args.row = row
+    args.columns = columns
+    args.attributes = attributes
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_getRowWithColumns(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getRowWithColumns_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.io is not None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRowWithColumns failed: unknown result");
+
+  def getRowTs(self, tableName, row, timestamp, attributes):
+    """
+    Get all the data for the specified table and row at the specified
+    timestamp. Returns an empty list if the row does not exist.
+
+    @return TRowResult containing the row and map of columns to TCells
+
+    Parameters:
+     - tableName: name of the table
+     - row: row key
+     - timestamp: timestamp
+     - attributes: Get attributes
+    """
+    self.send_getRowTs(tableName, row, timestamp, attributes)
+    return self.recv_getRowTs()
+
+  def send_getRowTs(self, tableName, row, timestamp, attributes):
+    self._oprot.writeMessageBegin('getRowTs', TMessageType.CALL, self._seqid)
+    args = getRowTs_args()
+    args.tableName = tableName
+    args.row = row
+    args.timestamp = timestamp
+    args.attributes = attributes
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_getRowTs(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getRowTs_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.io is not None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRowTs failed: unknown result");
+
+  def getRowWithColumnsTs(self, tableName, row, columns, timestamp, attributes):
+    """
+    Get the specified columns for the specified table and row at the specified
+    timestamp. Returns an empty list if the row does not exist.
+
+    @return TRowResult containing the row and map of columns to TCells
+
+    Parameters:
+     - tableName: name of table
+     - row: row key
+     - columns: List of columns to return, null for all columns
+     - timestamp
+     - attributes: Get attributes
+    """
+    self.send_getRowWithColumnsTs(tableName, row, columns, timestamp, attributes)
+    return self.recv_getRowWithColumnsTs()
+
+  def send_getRowWithColumnsTs(self, tableName, row, columns, timestamp, attributes):
+    self._oprot.writeMessageBegin('getRowWithColumnsTs', TMessageType.CALL, self._seqid)
+    args = getRowWithColumnsTs_args()
+    args.tableName = tableName
+    args.row = row
+    args.columns = columns
+    args.timestamp = timestamp
+    args.attributes = attributes
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_getRowWithColumnsTs(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getRowWithColumnsTs_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.io is not None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRowWithColumnsTs failed: unknown result");
+
+  def getRows(self, tableName, rows, attributes):
+    """
+    Get all the data for the specified table and rows at the latest
+    timestamp. Returns an empty list if no rows exist.
+
+    @return TRowResult containing the rows and map of columns to TCells
+
+    Parameters:
+     - tableName: name of table
+     - rows: row keys
+     - attributes: Get attributes
+    """
+    self.send_getRows(tableName, rows, attributes)
+    return self.recv_getRows()
+
+  def send_getRows(self, tableName, rows, attributes):
+    self._oprot.writeMessageBegin('getRows', TMessageType.CALL, self._seqid)
+    args = getRows_args()
+    args.tableName = tableName
+    args.rows = rows
+    args.attributes = attributes
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_getRows(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getRows_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.io is not None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRows failed: unknown result");
+
+  def getRowsWithColumns(self, tableName, rows, columns, attributes):
+    """
+    Get the specified columns for the specified table and rows at the latest
+    timestamp. Returns an empty list if no rows exist.
+
+    @return TRowResult containing the rows and map of columns to TCells
+
+    Parameters:
+     - tableName: name of table
+     - rows: row keys
+     - columns: List of columns to return, null for all columns
+     - attributes: Get attributes
+    """
+    self.send_getRowsWithColumns(tableName, rows, columns, attributes)
+    return self.recv_getRowsWithColumns()
+
+  def send_getRowsWithColumns(self, tableName, rows, columns, attributes):
+    self._oprot.writeMessageBegin('getRowsWithColumns', TMessageType.CALL, self._seqid)
+    args = getRowsWithColumns_args()
+    args.tableName = tableName
+    args.rows = rows
+    args.columns = columns
+    args.attributes = attributes
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_getRowsWithColumns(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getRowsWithColumns_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.io is not None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRowsWithColumns failed: unknown result");
+
+  def getRowsTs(self, tableName, rows, timestamp, attributes):
+    """
+    Get all the data for the specified table and rows at the specified
+    timestamp. Returns an empty list if no rows exist.
+
+    @return TRowResult containing the rows and map of columns to TCells
+
+    Parameters:
+     - tableName: name of the table
+     - rows: row keys
+     - timestamp: timestamp
+     - attributes: Get attributes
+    """
+    self.send_getRowsTs(tableName, rows, timestamp, attributes)
+    return self.recv_getRowsTs()
+
+  def send_getRowsTs(self, tableName, rows, timestamp, attributes):
+    self._oprot.writeMessageBegin('getRowsTs', TMessageType.CALL, self._seqid)
+    args = getRowsTs_args()
+    args.tableName = tableName
+    args.rows = rows
+    args.timestamp = timestamp
+    args.attributes = attributes
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_getRowsTs(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getRowsTs_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.io is not None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRowsTs failed: unknown result");
+
+  def getRowsWithColumnsTs(self, tableName, rows, columns, timestamp, attributes):
+    """
+    Get the specified columns for the specified table and rows at the specified
+    timestamp. Returns an empty list if no rows exist.
+
+    @return TRowResult containing the rows and map of columns to TCells
+
+    Parameters:
+     - tableName: name of table
+     - rows: row keys
+     - columns: List of columns to return, null for all columns
+     - timestamp
+     - attributes: Get attributes
+    """
+    self.send_getRowsWithColumnsTs(tableName, rows, columns, timestamp, attributes)
+    return self.recv_getRowsWithColumnsTs()
+
+  def send_getRowsWithColumnsTs(self, tableName, rows, columns, timestamp, attributes):
+    self._oprot.writeMessageBegin('getRowsWithColumnsTs', TMessageType.CALL, self._seqid)
+    args = getRowsWithColumnsTs_args()
+    args.tableName = tableName
+    args.rows = rows
+    args.columns = columns
+    args.timestamp = timestamp
+    args.attributes = attributes
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_getRowsWithColumnsTs(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getRowsWithColumnsTs_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.io is not None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRowsWithColumnsTs failed: unknown result");
+
+  def mutateRow(self, tableName, row, mutations, attributes):
+    """
+    Apply a series of mutations (updates/deletes) to a row in a
+    single transaction.  If an exception is thrown, then the
+    transaction is aborted.  Default current timestamp is used, and
+    all entries will have an identical timestamp.
+
+    Parameters:
+     - tableName: name of table
+     - row: row key
+     - mutations: list of mutation commands
+     - attributes: Mutation attributes
+    """
+    self.send_mutateRow(tableName, row, mutations, attributes)
+    self.recv_mutateRow()
+
+  def send_mutateRow(self, tableName, row, mutations, attributes):
+    self._oprot.writeMessageBegin('mutateRow', TMessageType.CALL, self._seqid)
+    args = mutateRow_args()
+    args.tableName = tableName
+    args.row = row
+    args.mutations = mutations
+    args.attributes = attributes
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_mutateRow(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = mutateRow_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.io is not None:
+      raise result.io
+    if result.ia is not None:
+      raise result.ia
+    return
+
+  def mutateRowTs(self, tableName, row, mutations, timestamp, attributes):
+    """
+    Apply a series of mutations (updates/deletes) to a row in a
+    single transaction.  If an exception is thrown, then the
+    transaction is aborted.  The specified timestamp is used, and
+    all entries will have an identical timestamp.
+
+    Parameters:
+     - tableName: name of table
+     - row: row key
+     - mutations: list of mutation commands
+     - timestamp: timestamp
+     - attributes: Mutation attributes
+    """
+    self.send_mutateRowTs(tableName, row, mutations, timestamp, attributes)
+    self.recv_mutateRowTs()
+
+  def send_mutateRowTs(self, tableName, row, mutations, timestamp, attributes):
+    self._oprot.writeMessageBegin('mutateRowTs', TMessageType.CALL, self._seqid)
+    args = mutateRowTs_args()
+    args.tableName = tableName
+    args.row = row
+    args.mutations = mutations
+    args.timestamp = timestamp
+    args.attributes = attributes
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_mutateRowTs(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = mutateRowTs_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.io is not None:
+      raise result.io
+    if result.ia is not None:
+      raise result.ia
+    return
+
+  def mutateRows(self, tableName, rowBatches, attributes):
+    """
+    Apply a series of batches (each a series of mutations on a single row)
+    in a single transaction.  If an exception is thrown, then the
+    transaction is aborted.  Default current timestamp is used, and
+    all entries will have an identical timestamp.
+
+    Parameters:
+     - tableName: name of table
+     - rowBatches: list of row batches
+     - attributes: Mutation attributes
+    """
+    self.send_mutateRows(tableName, rowBatches, attributes)
+    self.recv_mutateRows()
+
+  def send_mutateRows(self, tableName, rowBatches, attributes):
+    self._oprot.writeMessageBegin('mutateRows', TMessageType.CALL, self._seqid)
+    args = mutateRows_args()
+    args.tableName = tableName
+    args.rowBatches = rowBatches
+    args.attributes = attributes
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_mutateRows(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = mutateRows_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.io is not None:
+      raise result.io
+    if result.ia is not None:
+      raise result.ia
+    return
+
+  def mutateRowsTs(self, tableName, rowBatches, timestamp, attributes):
+    """
+    Apply a series of batches (each a series of mutations on a single row)
+    in a single transaction.  If an exception is thrown, then the
+    transaction is aborted.  The specified timestamp is used, and
+    all entries will have an identical timestamp.
+
+    Parameters:
+     - tableName: name of table
+     - rowBatches: list of row batches
+     - timestamp: timestamp
+     - attributes: Mutation attributes
+    """
+    self.send_mutateRowsTs(tableName, rowBatches, timestamp, attributes)
+    self.recv_mutateRowsTs()
+
+  def send_mutateRowsTs(self, tableName, rowBatches, timestamp, attributes):
+    self._oprot.writeMessageBegin('mutateRowsTs', TMessageType.CALL, self._seqid)
+    args = mutateRowsTs_args()
+    args.tableName = tableName
+    args.rowBatches = rowBatches
+    args.timestamp = timestamp
+    args.attributes = attributes
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_mutateRowsTs(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = mutateRowsTs_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.io is not None:
+      raise result.io
+    if result.ia is not None:
+      raise result.ia
+    return
+
+  def atomicIncrement(self, tableName, row, column, value):
+    """
+    Atomically increment the column value specified.  Returns the next value post increment.
+
+    Parameters:
+     - tableName: name of table
+     - row: row to increment
+     - column: name of column
+     - value: amount to increment by
+    """
+    self.send_atomicIncrement(tableName, row, column, value)
+    return self.recv_atomicIncrement()
+
+  def send_atomicIncrement(self, tableName, row, column, value):
+    self._oprot.writeMessageBegin('atomicIncrement', TMessageType.CALL, self._seqid)
+    args = atomicIncrement_args()
+    args.tableName = tableName
+    args.row = row
+    args.column = column
+    args.value = value
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_atomicIncrement(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = atomicIncrement_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.io is not None:
+      raise result.io
+    if result.ia is not None:
+      raise result.ia
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "atomicIncrement failed: unknown result");
+
+  def deleteAll(self, tableName, row, column, attributes):
+    """
+    Delete all cells that match the passed row and column.
+
+    Parameters:
+     - tableName: name of table
+     - row: Row to update
+     - column: name of column whose value is to be deleted
+     - attributes: Delete attributes
+    """
+    self.send_deleteAll(tableName, row, column, attributes)
+    self.recv_deleteAll()
+
+  def send_deleteAll(self, tableName, row, column, attributes):
+    self._oprot.writeMessageBegin('deleteAll', TMessageType.CALL, self._seqid)
+    args = deleteAll_args()
+    args.tableName = tableName
+    args.row = row
+    args.column = column
+    args.attributes = attributes
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_deleteAll(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = deleteAll_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.io is not None:
+      raise result.io
+    return
+
+  def deleteAllTs(self, tableName, row, column, timestamp, attributes):
+    """
+    Delete all cells that match the passed row and column and whose
+    timestamp is equal-to or older than the passed timestamp.
+
+    Parameters:
+     - tableName: name of table
+     - row: Row to update
+     - column: name of column whose value is to be deleted
+     - timestamp: timestamp
+     - attributes: Delete attributes
+    """
+    self.send_deleteAllTs(tableName, row, column, timestamp, attributes)
+    self.recv_deleteAllTs()
+
+  def send_deleteAllTs(self, tableName, row, column, timestamp, attributes):
+    self._oprot.writeMessageBegin('deleteAllTs', TMessageType.CALL, self._seqid)
+    args = deleteAllTs_args()
+    args.tableName = tableName
+    args.row = row
+    args.column = column
+    args.timestamp = timestamp
+    args.attributes = attributes
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_deleteAllTs(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = deleteAllTs_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.io is not None:
+      raise result.io
+    return
+
+  def deleteAllRow(self, tableName, row, attributes):
+    """
+    Completely delete the row's cells.
+
+    Parameters:
+     - tableName: name of table
+     - row: key of the row to be completely deleted.
+     - attributes: Delete attributes
+    """
+    self.send_deleteAllRow(tableName, row, attributes)
+    self.recv_deleteAllRow()
+
+  def send_deleteAllRow(self, tableName, row, attributes):
+    self._oprot.writeMessageBegin('deleteAllRow', TMessageType.CALL, self._seqid)
+    args = deleteAllRow_args()
+    args.tableName = tableName
+    args.row = row
+    args.attributes = attributes
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_deleteAllRow(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = deleteAllRow_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.io is not None:
+      raise result.io
+    return
+
+  def increment(self, increment):
+    """
+    Increment a cell by the ammount.
+    Increments can be applied async if hbase.regionserver.thrift.coalesceIncrement is set to true.
+    False is the default.  Turn to true if you need the extra performance and can accept some
+    data loss if a thrift server dies with increments still in the queue.
+
+    Parameters:
+     - increment: The single increment to apply
+    """
+    self.send_increment(increment)
+    self.recv_increment()
+
+  def send_increment(self, increment):
+    self._oprot.writeMessageBegin('increment', TMessageType.CALL, self._seqid)
+    args = increment_args()
+    args.increment = increment
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_increment(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = increment_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.io is not None:
+      raise result.io
+    return
+
+  def incrementRows(self, increments):
+    """
+    Parameters:
+     - increments: The list of increments
+    """
+    self.send_incrementRows(increments)
+    self.recv_incrementRows()
+
+  def send_incrementRows(self, increments):
+    self._oprot.writeMessageBegin('incrementRows', TMessageType.CALL, self._seqid)
+    args = incrementRows_args()
+    args.increments = increments
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_incrementRows(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = incrementRows_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.io is not None:
+      raise result.io
+    return
+
+  def deleteAllRowTs(self, tableName, row, timestamp, attributes):
+    """
+    Completely delete the row's cells marked with a timestamp
+    equal-to or older than the passed timestamp.
+
+    Parameters:
+     - tableName: name of table
+     - row: key of the row to be completely deleted.
+     - timestamp: timestamp
+     - attributes: Delete attributes
+    """
+    self.send_deleteAllRowTs(tableName, row, timestamp, attributes)
+    self.recv_deleteAllRowTs()
+
+  def send_deleteAllRowTs(self, tableName, row, timestamp, attributes):
+    self._oprot.writeMessageBegin('deleteAllRowTs', TMessageType.CALL, self._seqid)
+    args = deleteAllRowTs_args()
+    args.tableName = tableName
+    args.row = row
+    args.timestamp = timestamp
+    args.attributes = attributes
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_deleteAllRowTs(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = deleteAllRowTs_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.io is not None:
+      raise result.io
+    return
+
+  def scannerOpenWithScan(self, tableName, scan, attributes):
+    """
+    Get a scanner on the current table, using the Scan instance
+    for the scan parameters.
+
+    Parameters:
+     - tableName: name of table
+     - scan: Scan instance
+     - attributes: Scan attributes
+    """
+    self.send_scannerOpenWithScan(tableName, scan, attributes)
+    return self.recv_scannerOpenWithScan()
+
+  def send_scannerOpenWithScan(self, tableName, scan, attributes):
+    self._oprot.writeMessageBegin('scannerOpenWithScan', TMessageType.CALL, self._seqid)
+    args = scannerOpenWithScan_args()
+    args.tableName = tableName
+    args.scan = scan
+    args.attributes = attributes
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_scannerOpenWithScan(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = scannerOpenWithScan_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.io is not None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpenWithScan failed: unknown result");
+
+  def scannerOpen(self, tableName, startRow, columns, attributes):
+    """
+    Get a scanner on the current table starting at the specified row and
+    ending at the last row in the table.  Return the specified columns.
+
+    @return scanner id to be used with other scanner procedures
+
+    Parameters:
+     - tableName: name of table
+     - startRow: Starting row in table to scan.
+    Send "" (empty string) to start at the first row.
+     - columns: columns to scan. If column name is a column family, all
+    columns of the specified column family are returned. It's also possible
+    to pass a regex in the column qualifier.
+     - attributes: Scan attributes
+    """
+    self.send_scannerOpen(tableName, startRow, columns, attributes)
+    return self.recv_scannerOpen()
+
+  def send_scannerOpen(self, tableName, startRow, columns, attributes):
+    self._oprot.writeMessageBegin('scannerOpen', TMessageType.CALL, self._seqid)
+    args = scannerOpen_args()
+    args.tableName = tableName
+    args.startRow = startRow
+    args.columns = columns
+    args.attributes = attributes
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_scannerOpen(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = scannerOpen_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.io is not None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpen failed: unknown result");
+
+  def scannerOpenWithStop(self, tableName, startRow, stopRow, columns, attributes):
+    """
+    Get a scanner on the current table starting and stopping at the
+    specified rows.  ending at the last row in the table.  Return the
+    specified columns.
+
+    @return scanner id to be used with other scanner procedures
+
+    Parameters:
+     - tableName: name of table
+     - startRow: Starting row in table to scan.
+    Send "" (empty string) to start at the first row.
+     - stopRow: row to stop scanning on. This row is *not* included in the
+    scanner's results
+     - columns: columns to scan. If column name is a column family, all
+    columns of the specified column family are returned. It's also possible
+    to pass a regex in the column qualifier.
+     - attributes: Scan attributes
+    """
+    self.send_scannerOpenWithStop(tableName, startRow, stopRow, columns, attributes)
+    return self.recv_scannerOpenWithStop()
+
+  def send_scannerOpenWithStop(self, tableName, startRow, stopRow, columns, attributes):
+    self._oprot.writeMessageBegin('scannerOpenWithStop', TMessageType.CALL, self._seqid)
+    args = scannerOpenWithStop_args()
+    args.tableName = tableName
+    args.startRow = startRow
+    args.stopRow = stopRow
+    args.columns = columns
+    args.attributes = attributes
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_scannerOpenWithStop(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = scannerOpenWithStop_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.io is not None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpenWithStop failed: unknown result");
+
+  def scannerOpenWithPrefix(self, tableName, startAndPrefix, columns, attributes):
+    """
+    Open a scanner for a given prefix.  That is all rows will have the specified
+    prefix. No other rows will be returned.
+
+    @return scanner id to use with other scanner calls
+
+    Parameters:
+     - tableName: name of table
+     - startAndPrefix: the prefix (and thus start row) of the keys you want
+     - columns: the columns you want returned
+     - attributes: Scan attributes
+    """
+    self.send_scannerOpenWithPrefix(tableName, startAndPrefix, columns, attributes)
+    return self.recv_scannerOpenWithPrefix()
+
+  def send_scannerOpenWithPrefix(self, tableName, startAndPrefix, columns, attributes):
+    self._oprot.writeMessageBegin('scannerOpenWithPrefix', TMessageType.CALL, self._seqid)
+    args = scannerOpenWithPrefix_args()
+    args.tableName = tableName
+    args.startAndPrefix = startAndPrefix
+    args.columns = columns
+    args.attributes = attributes
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_scannerOpenWithPrefix(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = scannerOpenWithPrefix_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.io is not None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpenWithPrefix failed: unknown result");
+
+  def scannerOpenTs(self, tableName, startRow, columns, timestamp, attributes):
+    """
+    Get a scanner on the current table starting at the specified row and
+    ending at the last row in the table.  Return the specified columns.
+    Only values with the specified timestamp are returned.
+
+    @return scanner id to be used with other scanner procedures
+
+    Parameters:
+     - tableName: name of table
+     - startRow: Starting row in table to scan.
+    Send "" (empty string) to start at the first row.
+     - columns: columns to scan. If column name is a column family, all
+    columns of the specified column family are returned. It's also possible
+    to pass a regex in the column qualifier.
+     - timestamp: timestamp
+     - attributes: Scan attributes
+    """
+    self.send_scannerOpenTs(tableName, startRow, columns, timestamp, attributes)
+    return self.recv_scannerOpenTs()
+
+  def send_scannerOpenTs(self, tableName, startRow, columns, timestamp, attributes):
+    self._oprot.writeMessageBegin('scannerOpenTs', TMessageType.CALL, self._seqid)
+    args = scannerOpenTs_args()
+    args.tableName = tableName
+    args.startRow = startRow
+    args.columns = columns
+    args.timestamp = timestamp
+    args.attributes = attributes
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_scannerOpenTs(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = scannerOpenTs_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.io is not None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpenTs failed: unknown result");
+
+  def scannerOpenWithStopTs(self, tableName, startRow, stopRow, columns, timestamp, attributes):
+    """
+    Get a scanner on the current table starting and stopping at the
+    specified rows.  ending at the last row in the table.  Return the
+    specified columns.  Only values with the specified timestamp are
+    returned.
+
+    @return scanner id to be used with other scanner procedures
+
+    Parameters:
+     - tableName: name of table
+     - startRow: Starting row in table to scan.
+    Send "" (empty string) to start at the first row.
+     - stopRow: row to stop scanning on. This row is *not* included in the
+    scanner's results
+     - columns: columns to scan. If column name is a column family, all
+    columns of the specified column family are returned. It's also possible
+    to pass a regex in the column qualifier.
+     - timestamp: timestamp
+     - attributes: Scan attributes
+    """
+    self.send_scannerOpenWithStopTs(tableName, startRow, stopRow, columns, timestamp, attributes)
+    return self.recv_scannerOpenWithStopTs()
+
+  def send_scannerOpenWithStopTs(self, tableName, startRow, stopRow, columns, timestamp, attributes):
+    self._oprot.writeMessageBegin('scannerOpenWithStopTs', TMessageType.CALL, self._seqid)
+    args = scannerOpenWithStopTs_args()
+    args.tableName = tableName
+    args.startRow = startRow
+    args.stopRow = stopRow
+    args.columns = columns
+    args.timestamp = timestamp
+    args.attributes = attributes
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_scannerOpenWithStopTs(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = scannerOpenWithStopTs_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.io is not None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "scannerOpenWithStopTs failed: unknown result");
+
+  def scannerGet(self, id):
+    """
+    Returns the scanner's current row value and advances to the next
+    row in the table.  When there are no more rows in the table, or a key
+    greater-than-or-equal-to the scanner's specified stopRow is reached,
+    an empty list is returned.
+
+    @return a TRowResult containing the current row and a map of the columns to TCells.
+
+    @throws IllegalArgument if ScannerID is invalid
+
+    @throws NotFound when the scanner reaches the end
+
+    Parameters:
+     - id: id of a scanner returned by scannerOpen
+    """
+    self.send_scannerGet(id)
+    return self.recv_scannerGet()
+
+  def send_scannerGet(self, id):
+    self._oprot.writeMessageBegin('scannerGet', TMessageType.CALL, self._seqid)
+    args = scannerGet_args()
+    args.id = id
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_scannerGet(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = scannerGet_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.io is not None:
+      raise result.io
+    if result.ia is not None:
+      raise result.ia
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "scannerGet failed: unknown result");
+
+  def scannerGetList(self, id, nbRows):
+    """
+    Returns, starting at the scanner's current row value nbRows worth of
+    rows and advances to the next row in the table.  When there are no more
+    rows in the table, or a key greater-than-or-equal-to the scanner's
+    specified stopRow is reached,  an empty list is returned.
+
+    @return a TRowResult containing the current row and a map of the columns to TCells.
+
+    @throws IllegalArgument if ScannerID is invalid
+
+    @throws NotFound when the scanner reaches the end
+
+    Parameters:
+     - id: id of a scanner returned by scannerOpen
+     - nbRows: number of results to return
+    """
+    self.send_scannerGetList(id, nbRows)
+    return self.recv_scannerGetList()
+
+  def send_scannerGetList(self, id, nbRows):
+    self._oprot.writeMessageBegin('scannerGetList', TMessageType.CALL, self._seqid)
+    args = scannerGetList_args()
+    args.id = id
+    args.nbRows = nbRows
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_scannerGetList(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = scannerGetList_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.io is not None:
+      raise result.io
+    if result.ia is not None:
+      raise result.ia
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "scannerGetList failed: unknown result");
+
+  def scannerClose(self, id):
+    """
+    Closes the server-state associated with an open scanner.
+
+    @throws IllegalArgument if ScannerID is invalid
+
+    Parameters:
+     - id: id of a scanner returned by scannerOpen
+    """
+    self.send_scannerClose(id)
+    self.recv_scannerClose()
+
+  def send_scannerClose(self, id):
+    self._oprot.writeMessageBegin('scannerClose', TMessageType.CALL, self._seqid)
+    args = scannerClose_args()
+    args.id = id
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_scannerClose(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = scannerClose_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.io is not None:
+      raise result.io
+    if result.ia is not None:
+      raise result.ia
+    return
+
+  def getRowOrBefore(self, tableName, row, family):
+    """
+    Get the row just before the specified one.
+
+    @return value for specified row/column
+
+    Parameters:
+     - tableName: name of table
+     - row: row key
+     - family: column name
+    """
+    self.send_getRowOrBefore(tableName, row, family)
+    return self.recv_getRowOrBefore()
+
+  def send_getRowOrBefore(self, tableName, row, family):
+    self._oprot.writeMessageBegin('getRowOrBefore', TMessageType.CALL, self._seqid)
+    args = getRowOrBefore_args()
+    args.tableName = tableName
+    args.row = row
+    args.family = family
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_getRowOrBefore(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getRowOrBefore_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.io is not None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRowOrBefore failed: unknown result");
+
+  def getRegionInfo(self, row):
+    """
+    Get the regininfo for the specified row. It scans
+    the metatable to find region's start and end keys.
+
+    @return value for specified row/column
+
+    Parameters:
+     - row: row key
+    """
+    self.send_getRegionInfo(row)
+    return self.recv_getRegionInfo()
+
+  def send_getRegionInfo(self, row):
+    self._oprot.writeMessageBegin('getRegionInfo', TMessageType.CALL, self._seqid)
+    args = getRegionInfo_args()
+    args.row = row
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+
+  def recv_getRegionInfo(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getRegionInfo_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.io is not None:
+      raise result.io
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRegionInfo failed: unknown result");
+
+
+class Processor(Iface, TProcessor):
+  def __init__(self, handler):
+    self._handler = handler
+    self._processMap = {}
+    self._processMap["enableTable"] = Processor.process_enableTable
+    self._processMap["disableTable"] = Processor.process_disableTable
+    self._processMap["isTableEnabled"] = Processor.process_isTableEnabled
+    self._processMap["compact"] = Processor.process_compact
+    self._processMap["majorCompact"] = Processor.process_majorCompact
+    self._processMap["getTableNames"] = Processor.process_getTableNames
+    self._processMap["getColumnDescriptors"] = Processor.process_getColumnDescriptors
+    self._processMap["getTableRegions"] = Processor.process_getTableRegions
+    self._processMap["createTable"] = Processor.process_createTable
+    self._processMap["deleteTable"] = Processor.process_deleteTable
+    self._processMap["get"] = Processor.process_get
+    self._processMap["getVer"] = Processor.process_getVer
+    self._processMap["getVerTs"] = Processor.process_getVerTs
+    self._processMap["getRow"] = Processor.process_getRow
+    self._processMap["getRowWithColumns"] = Processor.process_getRowWithColumns
+    self._processMap["getRowTs"] = Processor.process_getRowTs
+    self._processMap["getRowWithColumnsTs"] = Processor.process_getRowWithColumnsTs
+    self._processMap["getRows"] = Processor.process_getRows
+    self._processMap["getRowsWithColumns"] = Processor.process_getRowsWithColumns
+    self._processMap["getRowsTs"] = Processor.process_getRowsTs
+    self._processMap["getRowsWithColumnsTs"] = Processor.process_getRowsWithColumnsTs
+    self._processMap["mutateRow"] = Processor.process_mutateRow
+    self._processMap["mutateRowTs"] = Processor.process_mutateRowTs
+    self._processMap["mutateRows"] = Processor.process_mutateRows
+    self._processMap["mutateRowsTs"] = Processor.process_mutateRowsTs
+    self._processMap["atomicIncrement"] = Processor.process_atomicIncrement
+    self._processMap["deleteAll"] = Processor.process_deleteAll
+    self._processMap["deleteAllTs"] = Processor.process_deleteAllTs
+    self._processMap["deleteAllRow"] = Processor.process_deleteAllRow
+    self._processMap["increment"] = Processor.process_increment
+    self._processMap["incrementRows"] = Processor.process_incrementRows
+    self._processMap["deleteAllRowTs"] = Processor.process_deleteAllRowTs
+    self._processMap["scannerOpenWithScan"] = Processor.process_scannerOpenWithScan
+    self._processMap["scannerOpen"] = Processor.process_scannerOpen
+    self._processMap["scannerOpenWithStop"] = Processor.process_scannerOpenWithStop
+    self._processMap["scannerOpenWithPrefix"] = Processor.process_scannerOpenWithPrefix
+    self._processMap["scannerOpenTs"] = Processor.process_scannerOpenTs
+    self._processMap["scannerOpenWithStopTs"] = Processor.process_scannerOpenWithStopTs
+    self._processMap["scannerGet"] = Processor.process_scannerGet
+    self._processMap["scannerGetList"] = Processor.process_scannerGetList
+    self._processMap["scannerClose"] = Processor.process_scannerClose
+    self._processMap["getRowOrBefore"] = Processor.process_getRowOrBefore
+    self._processMap["getRegionInfo"] = Processor.process_getRegionInfo
+
+  def process(self, iprot, oprot):
+    (name, type, seqid) = iprot.readMessageBegin()
+    if name not in self._processMap:
+      iprot.skip(TType.STRUCT)
+      iprot.readMessageEnd()
+      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
+      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
+      x.write(oprot)
+      oprot.writeMessageEnd()
+      oprot.trans.flush()
+      return
+    else:
+      self._processMap[name](self, seqid, iprot, oprot)
+    return True
+
+  def process_enableTable(self, seqid, iprot, oprot):
+    args = enableTable_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = enableTable_result()
+    try:
+      self._handler.enableTable(args.tableName)
+    except IOError as io:
+      result.io = io
+    oprot.writeMessageBegin("enableTable", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_disableTable(self, seqid, iprot, oprot):
+    args = disableTable_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = disableTable_result()
+    try:
+      self._handler.disableTable(args.tableName)
+    except IOError as io:
+      result.io = io
+    oprot.writeMessageBegin("disableTable", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_isTableEnabled(self, seqid, iprot, oprot):
+    args = isTableEnabled_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = isTableEnabled_result()
+    try:
+      result.success = self._handler.isTableEnabled(args.tableName)
+    except IOError as io:
+      result.io = io
+    oprot.writeMessageBegin("isTableEnabled", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_compact(self, seqid, iprot, oprot):
+    args = compact_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = compact_result()
+    try:
+      self._handler.compact(args.tableNameOrRegionName)
+    except IOError as io:
+      result.io = io
+    oprot.writeMessageBegin("compact", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_majorCompact(self, seqid, iprot, oprot):
+    args = majorCompact_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = majorCompact_result()
+    try:
+      self._handler.majorCompact(args.tableNameOrRegionName)
+    except IOError as io:
+      result.io = io
+    oprot.writeMessageBegin("majorCompact", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_getTableNames(self, seqid, iprot, oprot):
+    args = getTableNames_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getTableNames_result()
+    try:
+      result.success = self._handler.getTableNames()
+    except IOError as io:
+      result.io = io
+    oprot.writeMessageBegin("getTableNames", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_getColumnDescriptors(self, seqid, iprot, oprot):
+    args = getColumnDescriptors_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getColumnDescriptors_result()
+    try:
+      result.success = self._handler.getColumnDescriptors(args.tableName)
+    except IOError as io:
+      result.io = io
+    oprot.writeMessageBegin("getColumnDescriptors", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_getTableRegions(self, seqid, iprot, oprot):
+    args = getTableRegions_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getTableRegions_result()
+    try:
+      result.success = self._handler.getTableRegions(args.tableName)
+    except IOError as io:
+      result.io = io
+    oprot.writeMessageBegin("getTableRegions", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_createTable(self, seqid, iprot, oprot):
+    args = createTable_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = createTable_result()
+    try:
+      self._handler.createTable(args.tableName, args.columnFamilies)
+    except IOError as io:
+      result.io = io
+    except IllegalArgument as ia:
+      result.ia = ia
+    except AlreadyExists as exist:
+      result.exist = exist
+    oprot.writeMessageBegin("createTable", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_deleteTable(self, seqid, iprot, oprot):
+    args = deleteTable_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = deleteTable_result()
+    try:
+      self._handler.deleteTable(args.tableName)
+    except IOError as io:
+      result.io = io
+    oprot.writeMessageBegin("deleteTable", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_get(self, seqid, iprot, oprot):
+    args = get_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = get_result()
+    try:
+      result.success = self._handler.get(args.tableName, args.row, args.column, args.attributes)
+    except IOError as io:
+      result.io = io
+    oprot.writeMessageBegin("get", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_getVer(self, seqid, iprot, oprot):
+    args = getVer_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getVer_result()
+    try:
+      result.success = self._handler.getVer(args.tableName, args.row, args.column, args.numVersions, args.attributes)
+    except IOError as io:
+      result.io = io
+    oprot.writeMessageBegin("getVer", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_getVerTs(self, seqid, iprot, oprot):
+    args = getVerTs_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getVerTs_result()
+    try:
+      result.success = self._handler.getVerTs(args.tableName, args.row, args.column, args.timestamp, args.numVersions, args.attributes)
+    except IOError as io:
+      result.io = io
+    oprot.writeMessageBegin("getVerTs", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_getRow(self, seqid, iprot, oprot):
+    args = getRow_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getRow_result()
+    try:
+      result.success = self._handler.getRow(args.tableName, args.row, args.attributes)
+    except IOError as io:
+      result.io = io
+    oprot.writeMessageBegin("getRow", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_getRowWithColumns(self, seqid, iprot, oprot):
+    args = getRowWithColumns_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getRowWithColumns_result()
+    try:
+      result.success = self._handler.getRowWithColumns(args.tableName, args.row, args.columns, args.attributes)
+    except IOError as io:
+      result.io = io
+    oprot.writeMessageBegin("getRowWithColumns", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+
+  def process_getRowTs(self, seqid, iprot, oprot):
+    args = getRowTs_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getRowTs_result()
+    try:
+      result.success = self._handler.getRowTs(args.tableName, args.row, args.timestamp, args.attributes)

[... 7640 lines stripped ...]