#
# Autogenerated by Thrift Compiler (0.10.0)
#
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
#
#  options string: py
#

from thrift.Thrift import TType, TMessageType, TFrozenDict, TException, TApplicationException
from thrift.protocol.TProtocol import TProtocolException
import sys
import logging
from .ttypes import *
from thrift.Thrift import TProcessor
from thrift.transport import TTransport


class Iface(object):
    def login(self, auth_request):
        """
        Parameters:
         - auth_request
        """
        pass

    def set_keyspace(self, keyspace):
        """
        Parameters:
         - keyspace
        """
        pass

    def get(self, key, column_path, consistency_level):
        """
        Get the Column or SuperColumn at the given column_path. If no value is present, NotFoundException is thrown. (This is
        the only method that can throw an exception under non-failure conditions.)

        Parameters:
         - key
         - column_path
         - consistency_level
        """
        pass

    def get_slice(self, key, column_parent, predicate, consistency_level):
        """
        Get the group of columns contained by column_parent (either a ColumnFamily name or a ColumnFamily/SuperColumn name
        pair) specified by the given SlicePredicate. If no matching values are found, an empty list is returned.

        Parameters:
         - key
         - column_parent
         - predicate
         - consistency_level
        """
        pass

    def get_count(self, key, column_parent, predicate, consistency_level):
        """
        returns the number of columns matching <code>predicate</code> for a particular <code>key</code>,
        <code>ColumnFamily</code> and optionally <code>SuperColumn</code>.

        Parameters:
         - key
         - column_parent
         - predicate
         - consistency_level
        """
        pass

    def multiget_slice(self, keys, column_parent, predicate, consistency_level):
        """
        Performs a get_slice for column_parent and predicate for the given keys in parallel.

        Parameters:
         - keys
         - column_parent
         - predicate
         - consistency_level
        """
        pass

    def multiget_count(self, keys, column_parent, predicate, consistency_level):
        """
        Perform a get_count in parallel on the given list<binary> keys. The return value maps keys to the count found.

        Parameters:
         - keys
         - column_parent
         - predicate
         - consistency_level
        """
        pass

    def get_range_slices(self, column_parent, predicate, range, consistency_level):
        """
        returns a subset of columns for a contiguous range of keys.

        Parameters:
         - column_parent
         - predicate
         - range
         - consistency_level
        """
        pass

    def get_paged_slice(self, column_family, range, start_column, consistency_level):
        """
        returns a range of columns, wrapping to the next rows if necessary to collect max_results.

        Parameters:
         - column_family
         - range
         - start_column
         - consistency_level
        """
        pass

    def get_indexed_slices(self, column_parent, index_clause, column_predicate, consistency_level):
        """
        Returns the subset of columns specified in SlicePredicate for the rows matching the IndexClause
        @deprecated use get_range_slices instead with range.row_filter specified

        Parameters:
         - column_parent
         - index_clause
         - column_predicate
         - consistency_level
        """
        pass

    def insert(self, key, column_parent, column, consistency_level):
        """
        Insert a Column at the given column_parent.column_family and optional column_parent.super_column.

        Parameters:
         - key
         - column_parent
         - column
         - consistency_level
        """
        pass

    def add(self, key, column_parent, column, consistency_level):
        """
        Increment or decrement a counter.

        Parameters:
         - key
         - column_parent
         - column
         - consistency_level
        """
        pass

    def cas(self, key, column_family, expected, updates, serial_consistency_level, commit_consistency_level):
        """
        Atomic compare and set.

        If the cas is successfull, the success boolean in CASResult will be true and there will be no current_values.
        Otherwise, success will be false and current_values will contain the current values for the columns in
        expected (that, by definition of compare-and-set, will differ from the values in expected).

        A cas operation takes 2 consistency level. The first one, serial_consistency_level, simply indicates the
        level of serialization required. This can be either ConsistencyLevel.SERIAL or ConsistencyLevel.LOCAL_SERIAL.
        The second one, commit_consistency_level, defines the consistency level for the commit phase of the cas. This
        is a more traditional consistency level (the same CL than for traditional writes are accepted) that impact
        the visibility for reads of the operation. For instance, if commit_consistency_level is QUORUM, then it is
        guaranteed that a followup QUORUM read will see the cas write (if that one was successful obviously). If
        commit_consistency_level is ANY, you will need to use a SERIAL/LOCAL_SERIAL read to be guaranteed to see
        the write.

        Parameters:
         - key
         - column_family
         - expected
         - updates
         - serial_consistency_level
         - commit_consistency_level
        """
        pass

    def remove(self, key, column_path, timestamp, consistency_level):
        """
        Remove data from the row specified by key at the granularity specified by column_path, and the given timestamp. Note
        that all the values in column_path besides column_path.column_family are truly optional: you can remove the entire
        row by just specifying the ColumnFamily, or you can remove a SuperColumn or a single Column by specifying those levels too.

        Parameters:
         - key
         - column_path
         - timestamp
         - consistency_level
        """
        pass

    def remove_counter(self, key, path, consistency_level):
        """
        Remove a counter at the specified location.
        Note that counters have limited support for deletes: if you remove a counter, you must wait to issue any following update
        until the delete has reached all the nodes and all of them have been fully compacted.

        Parameters:
         - key
         - path
         - consistency_level
        """
        pass

    def batch_mutate(self, mutation_map, consistency_level):
        """
          Mutate many columns or super columns for many row keys. See also: Mutation.

          mutation_map maps key to column family to a list of Mutation objects to take place at that scope.
        *

        Parameters:
         - mutation_map
         - consistency_level
        """
        pass

    def atomic_batch_mutate(self, mutation_map, consistency_level):
        """
          Atomically mutate many columns or super columns for many row keys. See also: Mutation.

          mutation_map maps key to column family to a list of Mutation objects to take place at that scope.
        *

        Parameters:
         - mutation_map
         - consistency_level
        """
        pass

    def truncate(self, cfname):
        """
        Truncate will mark and entire column family as deleted.
        From the user's perspective a successful call to truncate will result complete data deletion from cfname.
        Internally, however, disk space will not be immediatily released, as with all deletes in cassandra, this one
        only marks the data as deleted.
        The operation succeeds only if all hosts in the cluster at available and will throw an UnavailableException if
        some hosts are down.

        Parameters:
         - cfname
        """
        pass

    def get_multi_slice(self, request):
        """
        Select multiple slices of a key in a single RPC operation

        Parameters:
         - request
        """
        pass

    def describe_schema_versions(self):
        """
        for each schema version present in the cluster, returns a list of nodes at that version.
        hosts that do not respond will be under the key DatabaseDescriptor.INITIAL_VERSION.
        the cluster is all on the same version if the size of the map is 1.
        """
        pass

    def describe_keyspaces(self):
        """
        list the defined keyspaces in this cluster
        """
        pass

    def describe_cluster_name(self):
        """
        get the cluster name
        """
        pass

    def describe_version(self):
        """
        get the thrift api version
        """
        pass

    def describe_ring(self, keyspace):
        """
        get the token ring: a map of ranges to host addresses,
        represented as a set of TokenRange instead of a map from range
        to list of endpoints, because you can't use Thrift structs as
        map keys:
        https://issues.apache.org/jira/browse/THRIFT-162

        for the same reason, we can't return a set here, even though
        order is neither important nor predictable.

        Parameters:
         - keyspace
        """
        pass

    def describe_local_ring(self, keyspace):
        """
        same as describe_ring, but considers only nodes in the local DC

        Parameters:
         - keyspace
        """
        pass

    def describe_token_map(self):
        """
        get the mapping between token->node ip
        without taking replication into consideration
        https://issues.apache.org/jira/browse/CASSANDRA-4092
        """
        pass

    def describe_partitioner(self):
        """
        returns the partitioner used by this cluster
        """
        pass

    def describe_snitch(self):
        """
        returns the snitch used by this cluster
        """
        pass

    def describe_keyspace(self, keyspace):
        """
        describe specified keyspace

        Parameters:
         - keyspace
        """
        pass

    def describe_splits(self, cfName, start_token, end_token, keys_per_split):
        """
        experimental API for hadoop/parallel query support.
        may change violently and without warning.

        returns list of token strings such that first subrange is (list[0], list[1]],
        next is (list[1], list[2]], etc.

        Parameters:
         - cfName
         - start_token
         - end_token
         - keys_per_split
        """
        pass

    def trace_next_query(self):
        """
        Enables tracing for the next query in this connection and returns the UUID for that trace session
        The next query will be traced idependently of trace probability and the returned UUID can be used to query the trace keyspace
        """
        pass

    def describe_splits_ex(self, cfName, start_token, end_token, keys_per_split):
        """
        Parameters:
         - cfName
         - start_token
         - end_token
         - keys_per_split
        """
        pass

    def system_add_column_family(self, cf_def):
        """
        adds a column family. returns the new schema id.

        Parameters:
         - cf_def
        """
        pass

    def system_drop_column_family(self, column_family):
        """
        drops a column family. returns the new schema id.

        Parameters:
         - column_family
        """
        pass

    def system_add_keyspace(self, ks_def):
        """
        adds a keyspace and any column families that are part of it. returns the new schema id.

        Parameters:
         - ks_def
        """
        pass

    def system_drop_keyspace(self, keyspace):
        """
        drops a keyspace and any column families that are part of it. returns the new schema id.

        Parameters:
         - keyspace
        """
        pass

    def system_update_keyspace(self, ks_def):
        """
        updates properties of a keyspace. returns the new schema id.

        Parameters:
         - ks_def
        """
        pass

    def system_update_column_family(self, cf_def):
        """
        updates properties of a column family. returns the new schema id.

        Parameters:
         - cf_def
        """
        pass

    def execute_cql_query(self, query, compression):
        """
        @deprecated Throws InvalidRequestException since 2.2. Please use the CQL3 version instead.

        Parameters:
         - query
         - compression
        """
        pass

    def execute_cql3_query(self, query, compression, consistency):
        """
        Executes a CQL3 (Cassandra Query Language) statement and returns a
        CqlResult containing the results.

        Parameters:
         - query
         - compression
         - consistency
        """
        pass

    def prepare_cql_query(self, query, compression):
        """
        @deprecated Throws InvalidRequestException since 2.2. Please use the CQL3 version instead.

        Parameters:
         - query
         - compression
        """
        pass

    def prepare_cql3_query(self, query, compression):
        """
        Prepare a CQL3 (Cassandra Query Language) statement by compiling and returning
        - the type of CQL statement
        - an id token of the compiled CQL stored on the server side.
        - a count of the discovered bound markers in the statement

        Parameters:
         - query
         - compression
        """
        pass

    def execute_prepared_cql_query(self, itemId, values):
        """
        @deprecated Throws InvalidRequestException since 2.2. Please use the CQL3 version instead.

        Parameters:
         - itemId
         - values
        """
        pass

    def execute_prepared_cql3_query(self, itemId, values, consistency):
        """
        Executes a prepared CQL3 (Cassandra Query Language) statement by passing an id token, a list of variables
        to bind, and the consistency level, and returns a CqlResult containing the results.

        Parameters:
         - itemId
         - values
         - consistency
        """
        pass

    def set_cql_version(self, version):
        """
        @deprecated This is now a no-op. Please use the CQL3 specific methods instead.

        Parameters:
         - version
        """
        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 login(self, auth_request):
        """
        Parameters:
         - auth_request
        """
        self.send_login(auth_request)
        self.recv_login()

    def send_login(self, auth_request):
        self._oprot.writeMessageBegin('login', TMessageType.CALL, self._seqid)
        args = login_args()
        args.auth_request = auth_request
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_login(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = login_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.authnx is not None:
            raise result.authnx
        if result.authzx is not None:
            raise result.authzx
        return

    def set_keyspace(self, keyspace):
        """
        Parameters:
         - keyspace
        """
        self.send_set_keyspace(keyspace)
        self.recv_set_keyspace()

    def send_set_keyspace(self, keyspace):
        self._oprot.writeMessageBegin('set_keyspace', TMessageType.CALL, self._seqid)
        args = set_keyspace_args()
        args.keyspace = keyspace
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_set_keyspace(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = set_keyspace_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ire is not None:
            raise result.ire
        return

    def get(self, key, column_path, consistency_level):
        """
        Get the Column or SuperColumn at the given column_path. If no value is present, NotFoundException is thrown. (This is
        the only method that can throw an exception under non-failure conditions.)

        Parameters:
         - key
         - column_path
         - consistency_level
        """
        self.send_get(key, column_path, consistency_level)
        return self.recv_get()

    def send_get(self, key, column_path, consistency_level):
        self._oprot.writeMessageBegin('get', TMessageType.CALL, self._seqid)
        args = get_args()
        args.key = key
        args.column_path = column_path
        args.consistency_level = consistency_level
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ire is not None:
            raise result.ire
        if result.nfe is not None:
            raise result.nfe
        if result.ue is not None:
            raise result.ue
        if result.te is not None:
            raise result.te
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get failed: unknown result")

    def get_slice(self, key, column_parent, predicate, consistency_level):
        """
        Get the group of columns contained by column_parent (either a ColumnFamily name or a ColumnFamily/SuperColumn name
        pair) specified by the given SlicePredicate. If no matching values are found, an empty list is returned.

        Parameters:
         - key
         - column_parent
         - predicate
         - consistency_level
        """
        self.send_get_slice(key, column_parent, predicate, consistency_level)
        return self.recv_get_slice()

    def send_get_slice(self, key, column_parent, predicate, consistency_level):
        self._oprot.writeMessageBegin('get_slice', TMessageType.CALL, self._seqid)
        args = get_slice_args()
        args.key = key
        args.column_parent = column_parent
        args.predicate = predicate
        args.consistency_level = consistency_level
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_slice(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_slice_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ire is not None:
            raise result.ire
        if result.ue is not None:
            raise result.ue
        if result.te is not None:
            raise result.te
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_slice failed: unknown result")

    def get_count(self, key, column_parent, predicate, consistency_level):
        """
        returns the number of columns matching <code>predicate</code> for a particular <code>key</code>,
        <code>ColumnFamily</code> and optionally <code>SuperColumn</code>.

        Parameters:
         - key
         - column_parent
         - predicate
         - consistency_level
        """
        self.send_get_count(key, column_parent, predicate, consistency_level)
        return self.recv_get_count()

    def send_get_count(self, key, column_parent, predicate, consistency_level):
        self._oprot.writeMessageBegin('get_count', TMessageType.CALL, self._seqid)
        args = get_count_args()
        args.key = key
        args.column_parent = column_parent
        args.predicate = predicate
        args.consistency_level = consistency_level
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_count(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_count_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ire is not None:
            raise result.ire
        if result.ue is not None:
            raise result.ue
        if result.te is not None:
            raise result.te
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_count failed: unknown result")

    def multiget_slice(self, keys, column_parent, predicate, consistency_level):
        """
        Performs a get_slice for column_parent and predicate for the given keys in parallel.

        Parameters:
         - keys
         - column_parent
         - predicate
         - consistency_level
        """
        self.send_multiget_slice(keys, column_parent, predicate, consistency_level)
        return self.recv_multiget_slice()

    def send_multiget_slice(self, keys, column_parent, predicate, consistency_level):
        self._oprot.writeMessageBegin('multiget_slice', TMessageType.CALL, self._seqid)
        args = multiget_slice_args()
        args.keys = keys
        args.column_parent = column_parent
        args.predicate = predicate
        args.consistency_level = consistency_level
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_multiget_slice(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = multiget_slice_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ire is not None:
            raise result.ire
        if result.ue is not None:
            raise result.ue
        if result.te is not None:
            raise result.te
        raise TApplicationException(TApplicationException.MISSING_RESULT, "multiget_slice failed: unknown result")

    def multiget_count(self, keys, column_parent, predicate, consistency_level):
        """
        Perform a get_count in parallel on the given list<binary> keys. The return value maps keys to the count found.

        Parameters:
         - keys
         - column_parent
         - predicate
         - consistency_level
        """
        self.send_multiget_count(keys, column_parent, predicate, consistency_level)
        return self.recv_multiget_count()

    def send_multiget_count(self, keys, column_parent, predicate, consistency_level):
        self._oprot.writeMessageBegin('multiget_count', TMessageType.CALL, self._seqid)
        args = multiget_count_args()
        args.keys = keys
        args.column_parent = column_parent
        args.predicate = predicate
        args.consistency_level = consistency_level
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_multiget_count(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = multiget_count_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ire is not None:
            raise result.ire
        if result.ue is not None:
            raise result.ue
        if result.te is not None:
            raise result.te
        raise TApplicationException(TApplicationException.MISSING_RESULT, "multiget_count failed: unknown result")

    def get_range_slices(self, column_parent, predicate, range, consistency_level):
        """
        returns a subset of columns for a contiguous range of keys.

        Parameters:
         - column_parent
         - predicate
         - range
         - consistency_level
        """
        self.send_get_range_slices(column_parent, predicate, range, consistency_level)
        return self.recv_get_range_slices()

    def send_get_range_slices(self, column_parent, predicate, range, consistency_level):
        self._oprot.writeMessageBegin('get_range_slices', TMessageType.CALL, self._seqid)
        args = get_range_slices_args()
        args.column_parent = column_parent
        args.predicate = predicate
        args.range = range
        args.consistency_level = consistency_level
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_range_slices(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_range_slices_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ire is not None:
            raise result.ire
        if result.ue is not None:
            raise result.ue
        if result.te is not None:
            raise result.te
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_range_slices failed: unknown result")

    def get_paged_slice(self, column_family, range, start_column, consistency_level):
        """
        returns a range of columns, wrapping to the next rows if necessary to collect max_results.

        Parameters:
         - column_family
         - range
         - start_column
         - consistency_level
        """
        self.send_get_paged_slice(column_family, range, start_column, consistency_level)
        return self.recv_get_paged_slice()

    def send_get_paged_slice(self, column_family, range, start_column, consistency_level):
        self._oprot.writeMessageBegin('get_paged_slice', TMessageType.CALL, self._seqid)
        args = get_paged_slice_args()
        args.column_family = column_family
        args.range = range
        args.start_column = start_column
        args.consistency_level = consistency_level
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_paged_slice(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_paged_slice_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ire is not None:
            raise result.ire
        if result.ue is not None:
            raise result.ue
        if result.te is not None:
            raise result.te
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_paged_slice failed: unknown result")

    def get_indexed_slices(self, column_parent, index_clause, column_predicate, consistency_level):
        """
        Returns the subset of columns specified in SlicePredicate for the rows matching the IndexClause
        @deprecated use get_range_slices instead with range.row_filter specified

        Parameters:
         - column_parent
         - index_clause
         - column_predicate
         - consistency_level
        """
        self.send_get_indexed_slices(column_parent, index_clause, column_predicate, consistency_level)
        return self.recv_get_indexed_slices()

    def send_get_indexed_slices(self, column_parent, index_clause, column_predicate, consistency_level):
        self._oprot.writeMessageBegin('get_indexed_slices', TMessageType.CALL, self._seqid)
        args = get_indexed_slices_args()
        args.column_parent = column_parent
        args.index_clause = index_clause
        args.column_predicate = column_predicate
        args.consistency_level = consistency_level
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_indexed_slices(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_indexed_slices_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ire is not None:
            raise result.ire
        if result.ue is not None:
            raise result.ue
        if result.te is not None:
            raise result.te
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_indexed_slices failed: unknown result")

    def insert(self, key, column_parent, column, consistency_level):
        """
        Insert a Column at the given column_parent.column_family and optional column_parent.super_column.

        Parameters:
         - key
         - column_parent
         - column
         - consistency_level
        """
        self.send_insert(key, column_parent, column, consistency_level)
        self.recv_insert()

    def send_insert(self, key, column_parent, column, consistency_level):
        self._oprot.writeMessageBegin('insert', TMessageType.CALL, self._seqid)
        args = insert_args()
        args.key = key
        args.column_parent = column_parent
        args.column = column
        args.consistency_level = consistency_level
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_insert(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = insert_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ire is not None:
            raise result.ire
        if result.ue is not None:
            raise result.ue
        if result.te is not None:
            raise result.te
        return

    def add(self, key, column_parent, column, consistency_level):
        """
        Increment or decrement a counter.

        Parameters:
         - key
         - column_parent
         - column
         - consistency_level
        """
        self.send_add(key, column_parent, column, consistency_level)
        self.recv_add()

    def send_add(self, key, column_parent, column, consistency_level):
        self._oprot.writeMessageBegin('add', TMessageType.CALL, self._seqid)
        args = add_args()
        args.key = key
        args.column_parent = column_parent
        args.column = column
        args.consistency_level = consistency_level
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_add(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = add_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ire is not None:
            raise result.ire
        if result.ue is not None:
            raise result.ue
        if result.te is not None:
            raise result.te
        return

    def cas(self, key, column_family, expected, updates, serial_consistency_level, commit_consistency_level):
        """
        Atomic compare and set.

        If the cas is successfull, the success boolean in CASResult will be true and there will be no current_values.
        Otherwise, success will be false and current_values will contain the current values for the columns in
        expected (that, by definition of compare-and-set, will differ from the values in expected).

        A cas operation takes 2 consistency level. The first one, serial_consistency_level, simply indicates the
        level of serialization required. This can be either ConsistencyLevel.SERIAL or ConsistencyLevel.LOCAL_SERIAL.
        The second one, commit_consistency_level, defines the consistency level for the commit phase of the cas. This
        is a more traditional consistency level (the same CL than for traditional writes are accepted) that impact
        the visibility for reads of the operation. For instance, if commit_consistency_level is QUORUM, then it is
        guaranteed that a followup QUORUM read will see the cas write (if that one was successful obviously). If
        commit_consistency_level is ANY, you will need to use a SERIAL/LOCAL_SERIAL read to be guaranteed to see
        the write.

        Parameters:
         - key
         - column_family
         - expected
         - updates
         - serial_consistency_level
         - commit_consistency_level
        """
        self.send_cas(key, column_family, expected, updates, serial_consistency_level, commit_consistency_level)
        return self.recv_cas()

    def send_cas(self, key, column_family, expected, updates, serial_consistency_level, commit_consistency_level):
        self._oprot.writeMessageBegin('cas', TMessageType.CALL, self._seqid)
        args = cas_args()
        args.key = key
        args.column_family = column_family
        args.expected = expected
        args.updates = updates
        args.serial_consistency_level = serial_consistency_level
        args.commit_consistency_level = commit_consistency_level
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_cas(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = cas_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ire is not None:
            raise result.ire
        if result.ue is not None:
            raise result.ue
        if result.te is not None:
            raise result.te
        raise TApplicationException(TApplicationException.MISSING_RESULT, "cas failed: unknown result")

    def remove(self, key, column_path, timestamp, consistency_level):
        """
        Remove data from the row specified by key at the granularity specified by column_path, and the given timestamp. Note
        that all the values in column_path besides column_path.column_family are truly optional: you can remove the entire
        row by just specifying the ColumnFamily, or you can remove a SuperColumn or a single Column by specifying those levels too.

        Parameters:
         - key
         - column_path
         - timestamp
         - consistency_level
        """
        self.send_remove(key, column_path, timestamp, consistency_level)
        self.recv_remove()

    def send_remove(self, key, column_path, timestamp, consistency_level):
        self._oprot.writeMessageBegin('remove', TMessageType.CALL, self._seqid)
        args = remove_args()
        args.key = key
        args.column_path = column_path
        args.timestamp = timestamp
        args.consistency_level = consistency_level
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_remove(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = remove_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ire is not None:
            raise result.ire
        if result.ue is not None:
            raise result.ue
        if result.te is not None:
            raise result.te
        return

    def remove_counter(self, key, path, consistency_level):
        """
        Remove a counter at the specified location.
        Note that counters have limited support for deletes: if you remove a counter, you must wait to issue any following update
        until the delete has reached all the nodes and all of them have been fully compacted.

        Parameters:
         - key
         - path
         - consistency_level
        """
        self.send_remove_counter(key, path, consistency_level)
        self.recv_remove_counter()

    def send_remove_counter(self, key, path, consistency_level):
        self._oprot.writeMessageBegin('remove_counter', TMessageType.CALL, self._seqid)
        args = remove_counter_args()
        args.key = key
        args.path = path
        args.consistency_level = consistency_level
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_remove_counter(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = remove_counter_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ire is not None:
            raise result.ire
        if result.ue is not None:
            raise result.ue
        if result.te is not None:
            raise result.te
        return

    def batch_mutate(self, mutation_map, consistency_level):
        """
          Mutate many columns or super columns for many row keys. See also: Mutation.

          mutation_map maps key to column family to a list of Mutation objects to take place at that scope.
        *

        Parameters:
         - mutation_map
         - consistency_level
        """
        self.send_batch_mutate(mutation_map, consistency_level)
        self.recv_batch_mutate()

    def send_batch_mutate(self, mutation_map, consistency_level):
        self._oprot.writeMessageBegin('batch_mutate', TMessageType.CALL, self._seqid)
        args = batch_mutate_args()
        args.mutation_map = mutation_map
        args.consistency_level = consistency_level
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_batch_mutate(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = batch_mutate_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ire is not None:
            raise result.ire
        if result.ue is not None:
            raise result.ue
        if result.te is not None:
            raise result.te
        return

    def atomic_batch_mutate(self, mutation_map, consistency_level):
        """
          Atomically mutate many columns or super columns for many row keys. See also: Mutation.

          mutation_map maps key to column family to a list of Mutation objects to take place at that scope.
        *

        Parameters:
         - mutation_map
         - consistency_level
        """
        self.send_atomic_batch_mutate(mutation_map, consistency_level)
        self.recv_atomic_batch_mutate()

    def send_atomic_batch_mutate(self, mutation_map, consistency_level):
        self._oprot.writeMessageBegin('atomic_batch_mutate', TMessageType.CALL, self._seqid)
        args = atomic_batch_mutate_args()
        args.mutation_map = mutation_map
        args.consistency_level = consistency_level
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_atomic_batch_mutate(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = atomic_batch_mutate_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ire is not None:
            raise result.ire
        if result.ue is not None:
            raise result.ue
        if result.te is not None:
            raise result.te
        return

    def truncate(self, cfname):
        """
        Truncate will mark and entire column family as deleted.
        From the user's perspective a successful call to truncate will result complete data deletion from cfname.
        Internally, however, disk space will not be immediatily released, as with all deletes in cassandra, this one
        only marks the data as deleted.
        The operation succeeds only if all hosts in the cluster at available and will throw an UnavailableException if
        some hosts are down.

        Parameters:
         - cfname
        """
        self.send_truncate(cfname)
        self.recv_truncate()

    def send_truncate(self, cfname):
        self._oprot.writeMessageBegin('truncate', TMessageType.CALL, self._seqid)
        args = truncate_args()
        args.cfname = cfname
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_truncate(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = truncate_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ire is not None:
            raise result.ire
        if result.ue is not None:
            raise result.ue
        if result.te is not None:
            raise result.te
        return

    def get_multi_slice(self, request):
        """
        Select multiple slices of a key in a single RPC operation

        Parameters:
         - request
        """
        self.send_get_multi_slice(request)
        return self.recv_get_multi_slice()

    def send_get_multi_slice(self, request):
        self._oprot.writeMessageBegin('get_multi_slice', TMessageType.CALL, self._seqid)
        args = get_multi_slice_args()
        args.request = request
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_get_multi_slice(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = get_multi_slice_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ire is not None:
            raise result.ire
        if result.ue is not None:
            raise result.ue
        if result.te is not None:
            raise result.te
        raise TApplicationException(TApplicationException.MISSING_RESULT, "get_multi_slice failed: unknown result")

    def describe_schema_versions(self):
        """
        for each schema version present in the cluster, returns a list of nodes at that version.
        hosts that do not respond will be under the key DatabaseDescriptor.INITIAL_VERSION.
        the cluster is all on the same version if the size of the map is 1.
        """
        self.send_describe_schema_versions()
        return self.recv_describe_schema_versions()

    def send_describe_schema_versions(self):
        self._oprot.writeMessageBegin('describe_schema_versions', TMessageType.CALL, self._seqid)
        args = describe_schema_versions_args()
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_describe_schema_versions(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = describe_schema_versions_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ire is not None:
            raise result.ire
        raise TApplicationException(TApplicationException.MISSING_RESULT, "describe_schema_versions failed: unknown result")

    def describe_keyspaces(self):
        """
        list the defined keyspaces in this cluster
        """
        self.send_describe_keyspaces()
        return self.recv_describe_keyspaces()

    def send_describe_keyspaces(self):
        self._oprot.writeMessageBegin('describe_keyspaces', TMessageType.CALL, self._seqid)
        args = describe_keyspaces_args()
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_describe_keyspaces(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = describe_keyspaces_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ire is not None:
            raise result.ire
        raise TApplicationException(TApplicationException.MISSING_RESULT, "describe_keyspaces failed: unknown result")

    def describe_cluster_name(self):
        """
        get the cluster name
        """
        self.send_describe_cluster_name()
        return self.recv_describe_cluster_name()

    def send_describe_cluster_name(self):
        self._oprot.writeMessageBegin('describe_cluster_name', TMessageType.CALL, self._seqid)
        args = describe_cluster_name_args()
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_describe_cluster_name(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = describe_cluster_name_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "describe_cluster_name failed: unknown result")

    def describe_version(self):
        """
        get the thrift api version
        """
        self.send_describe_version()
        return self.recv_describe_version()

    def send_describe_version(self):
        self._oprot.writeMessageBegin('describe_version', TMessageType.CALL, self._seqid)
        args = describe_version_args()
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_describe_version(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = describe_version_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "describe_version failed: unknown result")

    def describe_ring(self, keyspace):
        """
        get the token ring: a map of ranges to host addresses,
        represented as a set of TokenRange instead of a map from range
        to list of endpoints, because you can't use Thrift structs as
        map keys:
        https://issues.apache.org/jira/browse/THRIFT-162

        for the same reason, we can't return a set here, even though
        order is neither important nor predictable.

        Parameters:
         - keyspace
        """
        self.send_describe_ring(keyspace)
        return self.recv_describe_ring()

    def send_describe_ring(self, keyspace):
        self._oprot.writeMessageBegin('describe_ring', TMessageType.CALL, self._seqid)
        args = describe_ring_args()
        args.keyspace = keyspace
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_describe_ring(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = describe_ring_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ire is not None:
            raise result.ire
        raise TApplicationException(TApplicationException.MISSING_RESULT, "describe_ring failed: unknown result")

    def describe_local_ring(self, keyspace):
        """
        same as describe_ring, but considers only nodes in the local DC

        Parameters:
         - keyspace
        """
        self.send_describe_local_ring(keyspace)
        return self.recv_describe_local_ring()

    def send_describe_local_ring(self, keyspace):
        self._oprot.writeMessageBegin('describe_local_ring', TMessageType.CALL, self._seqid)
        args = describe_local_ring_args()
        args.keyspace = keyspace
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_describe_local_ring(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = describe_local_ring_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ire is not None:
            raise result.ire
        raise TApplicationException(TApplicationException.MISSING_RESULT, "describe_local_ring failed: unknown result")

    def describe_token_map(self):
        """
        get the mapping between token->node ip
        without taking replication into consideration
        https://issues.apache.org/jira/browse/CASSANDRA-4092
        """
        self.send_describe_token_map()
        return self.recv_describe_token_map()

    def send_describe_token_map(self):
        self._oprot.writeMessageBegin('describe_token_map', TMessageType.CALL, self._seqid)
        args = describe_token_map_args()
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_describe_token_map(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = describe_token_map_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ire is not None:
            raise result.ire
        raise TApplicationException(TApplicationException.MISSING_RESULT, "describe_token_map failed: unknown result")

    def describe_partitioner(self):
        """
        returns the partitioner used by this cluster
        """
        self.send_describe_partitioner()
        return self.recv_describe_partitioner()

    def send_describe_partitioner(self):
        self._oprot.writeMessageBegin('describe_partitioner', TMessageType.CALL, self._seqid)
        args = describe_partitioner_args()
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_describe_partitioner(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = describe_partitioner_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "describe_partitioner failed: unknown result")

    def describe_snitch(self):
        """
        returns the snitch used by this cluster
        """
        self.send_describe_snitch()
        return self.recv_describe_snitch()

    def send_describe_snitch(self):
        self._oprot.writeMessageBegin('describe_snitch', TMessageType.CALL, self._seqid)
        args = describe_snitch_args()
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_describe_snitch(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = describe_snitch_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "describe_snitch failed: unknown result")

    def describe_keyspace(self, keyspace):
        """
        describe specified keyspace

        Parameters:
         - keyspace
        """
        self.send_describe_keyspace(keyspace)
        return self.recv_describe_keyspace()

    def send_describe_keyspace(self, keyspace):
        self._oprot.writeMessageBegin('describe_keyspace', TMessageType.CALL, self._seqid)
        args = describe_keyspace_args()
        args.keyspace = keyspace
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_describe_keyspace(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = describe_keyspace_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.nfe is not None:
            raise result.nfe
        if result.ire is not None:
            raise result.ire
        raise TApplicationException(TApplicationException.MISSING_RESULT, "describe_keyspace failed: unknown result")

    def describe_splits(self, cfName, start_token, end_token, keys_per_split):
        """
        experimental API for hadoop/parallel query support.
        may change violently and without warning.

        returns list of token strings such that first subrange is (list[0], list[1]],
        next is (list[1], list[2]], etc.

        Parameters:
         - cfName
         - start_token
         - end_token
         - keys_per_split
        """
        self.send_describe_splits(cfName, start_token, end_token, keys_per_split)
        return self.recv_describe_splits()

    def send_describe_splits(self, cfName, start_token, end_token, keys_per_split):
        self._oprot.writeMessageBegin('describe_splits', TMessageType.CALL, self._seqid)
        args = describe_splits_args()
        args.cfName = cfName
        args.start_token = start_token
        args.end_token = end_token
        args.keys_per_split = keys_per_split
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_describe_splits(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = describe_splits_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ire is not None:
            raise result.ire
        raise TApplicationException(TApplicationException.MISSING_RESULT, "describe_splits failed: unknown result")

    def trace_next_query(self):
        """
        Enables tracing for the next query in this connection and returns the UUID for that trace session
        The next query will be traced idependently of trace probability and the returned UUID can be used to query the trace keyspace
        """
        self.send_trace_next_query()
        return self.recv_trace_next_query()

    def send_trace_next_query(self):
        self._oprot.writeMessageBegin('trace_next_query', TMessageType.CALL, self._seqid)
        args = trace_next_query_args()
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_trace_next_query(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = trace_next_query_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        raise TApplicationException(TApplicationException.MISSING_RESULT, "trace_next_query failed: unknown result")

    def describe_splits_ex(self, cfName, start_token, end_token, keys_per_split):
        """
        Parameters:
         - cfName
         - start_token
         - end_token
         - keys_per_split
        """
        self.send_describe_splits_ex(cfName, start_token, end_token, keys_per_split)
        return self.recv_describe_splits_ex()

    def send_describe_splits_ex(self, cfName, start_token, end_token, keys_per_split):
        self._oprot.writeMessageBegin('describe_splits_ex', TMessageType.CALL, self._seqid)
        args = describe_splits_ex_args()
        args.cfName = cfName
        args.start_token = start_token
        args.end_token = end_token
        args.keys_per_split = keys_per_split
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_describe_splits_ex(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = describe_splits_ex_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ire is not None:
            raise result.ire
        raise TApplicationException(TApplicationException.MISSING_RESULT, "describe_splits_ex failed: unknown result")

    def system_add_column_family(self, cf_def):
        """
        adds a column family. returns the new schema id.

        Parameters:
         - cf_def
        """
        self.send_system_add_column_family(cf_def)
        return self.recv_system_add_column_family()

    def send_system_add_column_family(self, cf_def):
        self._oprot.writeMessageBegin('system_add_column_family', TMessageType.CALL, self._seqid)
        args = system_add_column_family_args()
        args.cf_def = cf_def
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_system_add_column_family(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = system_add_column_family_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ire is not None:
            raise result.ire
        if result.sde is not None:
            raise result.sde
        raise TApplicationException(TApplicationException.MISSING_RESULT, "system_add_column_family failed: unknown result")

    def system_drop_column_family(self, column_family):
        """
        drops a column family. returns the new schema id.

        Parameters:
         - column_family
        """
        self.send_system_drop_column_family(column_family)
        return self.recv_system_drop_column_family()

    def send_system_drop_column_family(self, column_family):
        self._oprot.writeMessageBegin('system_drop_column_family', TMessageType.CALL, self._seqid)
        args = system_drop_column_family_args()
        args.column_family = column_family
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_system_drop_column_family(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = system_drop_column_family_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ire is not None:
            raise result.ire
        if result.sde is not None:
            raise result.sde
        raise TApplicationException(TApplicationException.MISSING_RESULT, "system_drop_column_family failed: unknown result")

    def system_add_keyspace(self, ks_def):
        """
        adds a keyspace and any column families that are part of it. returns the new schema id.

        Parameters:
         - ks_def
        """
        self.send_system_add_keyspace(ks_def)
        return self.recv_system_add_keyspace()

    def send_system_add_keyspace(self, ks_def):
        self._oprot.writeMessageBegin('system_add_keyspace', TMessageType.CALL, self._seqid)
        args = system_add_keyspace_args()
        args.ks_def = ks_def
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_system_add_keyspace(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = system_add_keyspace_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ire is not None:
            raise result.ire
        if result.sde is not None:
            raise result.sde
        raise TApplicationException(TApplicationException.MISSING_RESULT, "system_add_keyspace failed: unknown result")

    def system_drop_keyspace(self, keyspace):
        """
        drops a keyspace and any column families that are part of it. returns the new schema id.

        Parameters:
         - keyspace
        """
        self.send_system_drop_keyspace(keyspace)
        return self.recv_system_drop_keyspace()

    def send_system_drop_keyspace(self, keyspace):
        self._oprot.writeMessageBegin('system_drop_keyspace', TMessageType.CALL, self._seqid)
        args = system_drop_keyspace_args()
        args.keyspace = keyspace
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_system_drop_keyspace(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = system_drop_keyspace_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ire is not None:
            raise result.ire
        if result.sde is not None:
            raise result.sde
        raise TApplicationException(TApplicationException.MISSING_RESULT, "system_drop_keyspace failed: unknown result")

    def system_update_keyspace(self, ks_def):
        """
        updates properties of a keyspace. returns the new schema id.

        Parameters:
         - ks_def
        """
        self.send_system_update_keyspace(ks_def)
        return self.recv_system_update_keyspace()

    def send_system_update_keyspace(self, ks_def):
        self._oprot.writeMessageBegin('system_update_keyspace', TMessageType.CALL, self._seqid)
        args = system_update_keyspace_args()
        args.ks_def = ks_def
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_system_update_keyspace(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = system_update_keyspace_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ire is not None:
            raise result.ire
        if result.sde is not None:
            raise result.sde
        raise TApplicationException(TApplicationException.MISSING_RESULT, "system_update_keyspace failed: unknown result")

    def system_update_column_family(self, cf_def):
        """
        updates properties of a column family. returns the new schema id.

        Parameters:
         - cf_def
        """
        self.send_system_update_column_family(cf_def)
        return self.recv_system_update_column_family()

    def send_system_update_column_family(self, cf_def):
        self._oprot.writeMessageBegin('system_update_column_family', TMessageType.CALL, self._seqid)
        args = system_update_column_family_args()
        args.cf_def = cf_def
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_system_update_column_family(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = system_update_column_family_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ire is not None:
            raise result.ire
        if result.sde is not None:
            raise result.sde
        raise TApplicationException(TApplicationException.MISSING_RESULT, "system_update_column_family failed: unknown result")

    def execute_cql_query(self, query, compression):
        """
        @deprecated Throws InvalidRequestException since 2.2. Please use the CQL3 version instead.

        Parameters:
         - query
         - compression
        """
        self.send_execute_cql_query(query, compression)
        return self.recv_execute_cql_query()

    def send_execute_cql_query(self, query, compression):
        self._oprot.writeMessageBegin('execute_cql_query', TMessageType.CALL, self._seqid)
        args = execute_cql_query_args()
        args.query = query
        args.compression = compression
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_execute_cql_query(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = execute_cql_query_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ire is not None:
            raise result.ire
        if result.ue is not None:
            raise result.ue
        if result.te is not None:
            raise result.te
        if result.sde is not None:
            raise result.sde
        raise TApplicationException(TApplicationException.MISSING_RESULT, "execute_cql_query failed: unknown result")

    def execute_cql3_query(self, query, compression, consistency):
        """
        Executes a CQL3 (Cassandra Query Language) statement and returns a
        CqlResult containing the results.

        Parameters:
         - query
         - compression
         - consistency
        """
        self.send_execute_cql3_query(query, compression, consistency)
        return self.recv_execute_cql3_query()

    def send_execute_cql3_query(self, query, compression, consistency):
        self._oprot.writeMessageBegin('execute_cql3_query', TMessageType.CALL, self._seqid)
        args = execute_cql3_query_args()
        args.query = query
        args.compression = compression
        args.consistency = consistency
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_execute_cql3_query(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = execute_cql3_query_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ire is not None:
            raise result.ire
        if result.ue is not None:
            raise result.ue
        if result.te is not None:
            raise result.te
        if result.sde is not None:
            raise result.sde
        raise TApplicationException(TApplicationException.MISSING_RESULT, "execute_cql3_query failed: unknown result")

    def prepare_cql_query(self, query, compression):
        """
        @deprecated Throws InvalidRequestException since 2.2. Please use the CQL3 version instead.

        Parameters:
         - query
         - compression
        """
        self.send_prepare_cql_query(query, compression)
        return self.recv_prepare_cql_query()

    def send_prepare_cql_query(self, query, compression):
        self._oprot.writeMessageBegin('prepare_cql_query', TMessageType.CALL, self._seqid)
        args = prepare_cql_query_args()
        args.query = query
        args.compression = compression
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_prepare_cql_query(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = prepare_cql_query_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ire is not None:
            raise result.ire
        raise TApplicationException(TApplicationException.MISSING_RESULT, "prepare_cql_query failed: unknown result")

    def prepare_cql3_query(self, query, compression):
        """
        Prepare a CQL3 (Cassandra Query Language) statement by compiling and returning
        - the type of CQL statement
        - an id token of the compiled CQL stored on the server side.
        - a count of the discovered bound markers in the statement

        Parameters:
         - query
         - compression
        """
        self.send_prepare_cql3_query(query, compression)
        return self.recv_prepare_cql3_query()

    def send_prepare_cql3_query(self, query, compression):
        self._oprot.writeMessageBegin('prepare_cql3_query', TMessageType.CALL, self._seqid)
        args = prepare_cql3_query_args()
        args.query = query
        args.compression = compression
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_prepare_cql3_query(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = prepare_cql3_query_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ire is not None:
            raise result.ire
        raise TApplicationException(TApplicationException.MISSING_RESULT, "prepare_cql3_query failed: unknown result")

    def execute_prepared_cql_query(self, itemId, values):
        """
        @deprecated Throws InvalidRequestException since 2.2. Please use the CQL3 version instead.

        Parameters:
         - itemId
         - values
        """
        self.send_execute_prepared_cql_query(itemId, values)
        return self.recv_execute_prepared_cql_query()

    def send_execute_prepared_cql_query(self, itemId, values):
        self._oprot.writeMessageBegin('execute_prepared_cql_query', TMessageType.CALL, self._seqid)
        args = execute_prepared_cql_query_args()
        args.itemId = itemId
        args.values = values
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_execute_prepared_cql_query(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = execute_prepared_cql_query_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ire is not None:
            raise result.ire
        if result.ue is not None:
            raise result.ue
        if result.te is not None:
            raise result.te
        if result.sde is not None:
            raise result.sde
        raise TApplicationException(TApplicationException.MISSING_RESULT, "execute_prepared_cql_query failed: unknown result")

    def execute_prepared_cql3_query(self, itemId, values, consistency):
        """
        Executes a prepared CQL3 (Cassandra Query Language) statement by passing an id token, a list of variables
        to bind, and the consistency level, and returns a CqlResult containing the results.

        Parameters:
         - itemId
         - values
         - consistency
        """
        self.send_execute_prepared_cql3_query(itemId, values, consistency)
        return self.recv_execute_prepared_cql3_query()

    def send_execute_prepared_cql3_query(self, itemId, values, consistency):
        self._oprot.writeMessageBegin('execute_prepared_cql3_query', TMessageType.CALL, self._seqid)
        args = execute_prepared_cql3_query_args()
        args.itemId = itemId
        args.values = values
        args.consistency = consistency
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_execute_prepared_cql3_query(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = execute_prepared_cql3_query_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.success is not None:
            return result.success
        if result.ire is not None:
            raise result.ire
        if result.ue is not None:
            raise result.ue
        if result.te is not None:
            raise result.te
        if result.sde is not None:
            raise result.sde
        raise TApplicationException(TApplicationException.MISSING_RESULT, "execute_prepared_cql3_query failed: unknown result")

    def set_cql_version(self, version):
        """
        @deprecated This is now a no-op. Please use the CQL3 specific methods instead.

        Parameters:
         - version
        """
        self.send_set_cql_version(version)
        self.recv_set_cql_version()

    def send_set_cql_version(self, version):
        self._oprot.writeMessageBegin('set_cql_version', TMessageType.CALL, self._seqid)
        args = set_cql_version_args()
        args.version = version
        args.write(self._oprot)
        self._oprot.writeMessageEnd()
        self._oprot.trans.flush()

    def recv_set_cql_version(self):
        iprot = self._iprot
        (fname, mtype, rseqid) = iprot.readMessageBegin()
        if mtype == TMessageType.EXCEPTION:
            x = TApplicationException()
            x.read(iprot)
            iprot.readMessageEnd()
            raise x
        result = set_cql_version_result()
        result.read(iprot)
        iprot.readMessageEnd()
        if result.ire is not None:
            raise result.ire
        return


class Processor(Iface, TProcessor):
    def __init__(self, handler):
        self._handler = handler
        self._processMap = {}
        self._processMap["login"] = Processor.process_login
        self._processMap["set_keyspace"] = Processor.process_set_keyspace
        self._processMap["get"] = Processor.process_get
        self._processMap["get_slice"] = Processor.process_get_slice
        self._processMap["get_count"] = Processor.process_get_count
        self._processMap["multiget_slice"] = Processor.process_multiget_slice
        self._processMap["multiget_count"] = Processor.process_multiget_count
        self._processMap["get_range_slices"] = Processor.process_get_range_slices
        self._processMap["get_paged_slice"] = Processor.process_get_paged_slice
        self._processMap["get_indexed_slices"] = Processor.process_get_indexed_slices
        self._processMap["insert"] = Processor.process_insert
        self._processMap["add"] = Processor.process_add
        self._processMap["cas"] = Processor.process_cas
        self._processMap["remove"] = Processor.process_remove
        self._processMap["remove_counter"] = Processor.process_remove_counter
        self._processMap["batch_mutate"] = Processor.process_batch_mutate
        self._processMap["atomic_batch_mutate"] = Processor.process_atomic_batch_mutate
        self._processMap["truncate"] = Processor.process_truncate
        self._processMap["get_multi_slice"] = Processor.process_get_multi_slice
        self._processMap["describe_schema_versions"] = Processor.process_describe_schema_versions
        self._processMap["describe_keyspaces"] = Processor.process_describe_keyspaces
        self._processMap["describe_cluster_name"] = Processor.process_describe_cluster_name
        self._processMap["describe_version"] = Processor.process_describe_version
        self._processMap["describe_ring"] = Processor.process_describe_ring
        self._processMap["describe_local_ring"] = Processor.process_describe_local_ring
        self._processMap["describe_token_map"] = Processor.process_describe_token_map
        self._processMap["describe_partitioner"] = Processor.process_describe_partitioner
        self._processMap["describe_snitch"] = Processor.process_describe_snitch
        self._processMap["describe_keyspace"] = Processor.process_describe_keyspace
        self._processMap["describe_splits"] = Processor.process_describe_splits
        self._processMap["trace_next_query"] = Processor.process_trace_next_query
        self._processMap["describe_splits_ex"] = Processor.process_describe_splits_ex
        self._processMap["system_add_column_family"] = Processor.process_system_add_column_family
        self._processMap["system_drop_column_family"] = Processor.process_system_drop_column_family
        self._processMap["system_add_keyspace"] = Processor.process_system_add_keyspace
        self._processMap["system_drop_keyspace"] = Processor.process_system_drop_keyspace
        self._processMap["system_update_keyspace"] = Processor.process_system_update_keyspace
        self._processMap["system_update_column_family"] = Processor.process_system_update_column_family
        self._processMap["execute_cql_query"] = Processor.process_execute_cql_query
        self._processMap["execute_cql3_query"] = Processor.process_execute_cql3_query
        self._processMap["prepare_cql_query"] = Processor.process_prepare_cql_query
        self._processMap["prepare_cql3_query"] = Processor.process_prepare_cql3_query
        self._processMap["execute_prepared_cql_query"] = Processor.process_execute_prepared_cql_query
        self._processMap["execute_prepared_cql3_query"] = Processor.process_execute_prepared_cql3_query
        self._processMap["set_cql_version"] = Processor.process_set_cql_version

    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_login(self, seqid, iprot, oprot):
        args = login_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = login_result()
        try:
            self._handler.login(args.auth_request)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except AuthenticationException as authnx:
            msg_type = TMessageType.REPLY
            result.authnx = authnx
        except AuthorizationException as authzx:
            msg_type = TMessageType.REPLY
            result.authzx = authzx
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("login", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_set_keyspace(self, seqid, iprot, oprot):
        args = set_keyspace_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = set_keyspace_result()
        try:
            self._handler.set_keyspace(args.keyspace)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("set_keyspace", msg_type, 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.key, args.column_path, args.consistency_level)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except NotFoundException as nfe:
            msg_type = TMessageType.REPLY
            result.nfe = nfe
        except UnavailableException as ue:
            msg_type = TMessageType.REPLY
            result.ue = ue
        except TimedOutException as te:
            msg_type = TMessageType.REPLY
            result.te = te
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_slice(self, seqid, iprot, oprot):
        args = get_slice_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_slice_result()
        try:
            result.success = self._handler.get_slice(args.key, args.column_parent, args.predicate, args.consistency_level)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except UnavailableException as ue:
            msg_type = TMessageType.REPLY
            result.ue = ue
        except TimedOutException as te:
            msg_type = TMessageType.REPLY
            result.te = te
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_slice", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_count(self, seqid, iprot, oprot):
        args = get_count_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_count_result()
        try:
            result.success = self._handler.get_count(args.key, args.column_parent, args.predicate, args.consistency_level)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except UnavailableException as ue:
            msg_type = TMessageType.REPLY
            result.ue = ue
        except TimedOutException as te:
            msg_type = TMessageType.REPLY
            result.te = te
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_count", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_multiget_slice(self, seqid, iprot, oprot):
        args = multiget_slice_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = multiget_slice_result()
        try:
            result.success = self._handler.multiget_slice(args.keys, args.column_parent, args.predicate, args.consistency_level)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except UnavailableException as ue:
            msg_type = TMessageType.REPLY
            result.ue = ue
        except TimedOutException as te:
            msg_type = TMessageType.REPLY
            result.te = te
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("multiget_slice", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_multiget_count(self, seqid, iprot, oprot):
        args = multiget_count_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = multiget_count_result()
        try:
            result.success = self._handler.multiget_count(args.keys, args.column_parent, args.predicate, args.consistency_level)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except UnavailableException as ue:
            msg_type = TMessageType.REPLY
            result.ue = ue
        except TimedOutException as te:
            msg_type = TMessageType.REPLY
            result.te = te
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("multiget_count", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_range_slices(self, seqid, iprot, oprot):
        args = get_range_slices_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_range_slices_result()
        try:
            result.success = self._handler.get_range_slices(args.column_parent, args.predicate, args.range, args.consistency_level)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except UnavailableException as ue:
            msg_type = TMessageType.REPLY
            result.ue = ue
        except TimedOutException as te:
            msg_type = TMessageType.REPLY
            result.te = te
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_range_slices", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_paged_slice(self, seqid, iprot, oprot):
        args = get_paged_slice_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_paged_slice_result()
        try:
            result.success = self._handler.get_paged_slice(args.column_family, args.range, args.start_column, args.consistency_level)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except UnavailableException as ue:
            msg_type = TMessageType.REPLY
            result.ue = ue
        except TimedOutException as te:
            msg_type = TMessageType.REPLY
            result.te = te
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_paged_slice", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_indexed_slices(self, seqid, iprot, oprot):
        args = get_indexed_slices_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_indexed_slices_result()
        try:
            result.success = self._handler.get_indexed_slices(args.column_parent, args.index_clause, args.column_predicate, args.consistency_level)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except UnavailableException as ue:
            msg_type = TMessageType.REPLY
            result.ue = ue
        except TimedOutException as te:
            msg_type = TMessageType.REPLY
            result.te = te
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_indexed_slices", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_insert(self, seqid, iprot, oprot):
        args = insert_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = insert_result()
        try:
            self._handler.insert(args.key, args.column_parent, args.column, args.consistency_level)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except UnavailableException as ue:
            msg_type = TMessageType.REPLY
            result.ue = ue
        except TimedOutException as te:
            msg_type = TMessageType.REPLY
            result.te = te
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("insert", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_add(self, seqid, iprot, oprot):
        args = add_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = add_result()
        try:
            self._handler.add(args.key, args.column_parent, args.column, args.consistency_level)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except UnavailableException as ue:
            msg_type = TMessageType.REPLY
            result.ue = ue
        except TimedOutException as te:
            msg_type = TMessageType.REPLY
            result.te = te
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("add", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_cas(self, seqid, iprot, oprot):
        args = cas_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = cas_result()
        try:
            result.success = self._handler.cas(args.key, args.column_family, args.expected, args.updates, args.serial_consistency_level, args.commit_consistency_level)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except UnavailableException as ue:
            msg_type = TMessageType.REPLY
            result.ue = ue
        except TimedOutException as te:
            msg_type = TMessageType.REPLY
            result.te = te
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("cas", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_remove(self, seqid, iprot, oprot):
        args = remove_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = remove_result()
        try:
            self._handler.remove(args.key, args.column_path, args.timestamp, args.consistency_level)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except UnavailableException as ue:
            msg_type = TMessageType.REPLY
            result.ue = ue
        except TimedOutException as te:
            msg_type = TMessageType.REPLY
            result.te = te
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("remove", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_remove_counter(self, seqid, iprot, oprot):
        args = remove_counter_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = remove_counter_result()
        try:
            self._handler.remove_counter(args.key, args.path, args.consistency_level)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except UnavailableException as ue:
            msg_type = TMessageType.REPLY
            result.ue = ue
        except TimedOutException as te:
            msg_type = TMessageType.REPLY
            result.te = te
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("remove_counter", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_batch_mutate(self, seqid, iprot, oprot):
        args = batch_mutate_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = batch_mutate_result()
        try:
            self._handler.batch_mutate(args.mutation_map, args.consistency_level)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except UnavailableException as ue:
            msg_type = TMessageType.REPLY
            result.ue = ue
        except TimedOutException as te:
            msg_type = TMessageType.REPLY
            result.te = te
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("batch_mutate", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_atomic_batch_mutate(self, seqid, iprot, oprot):
        args = atomic_batch_mutate_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = atomic_batch_mutate_result()
        try:
            self._handler.atomic_batch_mutate(args.mutation_map, args.consistency_level)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except UnavailableException as ue:
            msg_type = TMessageType.REPLY
            result.ue = ue
        except TimedOutException as te:
            msg_type = TMessageType.REPLY
            result.te = te
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("atomic_batch_mutate", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_truncate(self, seqid, iprot, oprot):
        args = truncate_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = truncate_result()
        try:
            self._handler.truncate(args.cfname)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except UnavailableException as ue:
            msg_type = TMessageType.REPLY
            result.ue = ue
        except TimedOutException as te:
            msg_type = TMessageType.REPLY
            result.te = te
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("truncate", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_get_multi_slice(self, seqid, iprot, oprot):
        args = get_multi_slice_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = get_multi_slice_result()
        try:
            result.success = self._handler.get_multi_slice(args.request)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except UnavailableException as ue:
            msg_type = TMessageType.REPLY
            result.ue = ue
        except TimedOutException as te:
            msg_type = TMessageType.REPLY
            result.te = te
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("get_multi_slice", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_describe_schema_versions(self, seqid, iprot, oprot):
        args = describe_schema_versions_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = describe_schema_versions_result()
        try:
            result.success = self._handler.describe_schema_versions()
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("describe_schema_versions", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_describe_keyspaces(self, seqid, iprot, oprot):
        args = describe_keyspaces_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = describe_keyspaces_result()
        try:
            result.success = self._handler.describe_keyspaces()
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("describe_keyspaces", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_describe_cluster_name(self, seqid, iprot, oprot):
        args = describe_cluster_name_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = describe_cluster_name_result()
        try:
            result.success = self._handler.describe_cluster_name()
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("describe_cluster_name", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_describe_version(self, seqid, iprot, oprot):
        args = describe_version_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = describe_version_result()
        try:
            result.success = self._handler.describe_version()
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("describe_version", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_describe_ring(self, seqid, iprot, oprot):
        args = describe_ring_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = describe_ring_result()
        try:
            result.success = self._handler.describe_ring(args.keyspace)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("describe_ring", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_describe_local_ring(self, seqid, iprot, oprot):
        args = describe_local_ring_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = describe_local_ring_result()
        try:
            result.success = self._handler.describe_local_ring(args.keyspace)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("describe_local_ring", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_describe_token_map(self, seqid, iprot, oprot):
        args = describe_token_map_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = describe_token_map_result()
        try:
            result.success = self._handler.describe_token_map()
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("describe_token_map", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_describe_partitioner(self, seqid, iprot, oprot):
        args = describe_partitioner_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = describe_partitioner_result()
        try:
            result.success = self._handler.describe_partitioner()
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("describe_partitioner", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_describe_snitch(self, seqid, iprot, oprot):
        args = describe_snitch_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = describe_snitch_result()
        try:
            result.success = self._handler.describe_snitch()
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("describe_snitch", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_describe_keyspace(self, seqid, iprot, oprot):
        args = describe_keyspace_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = describe_keyspace_result()
        try:
            result.success = self._handler.describe_keyspace(args.keyspace)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except NotFoundException as nfe:
            msg_type = TMessageType.REPLY
            result.nfe = nfe
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("describe_keyspace", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_describe_splits(self, seqid, iprot, oprot):
        args = describe_splits_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = describe_splits_result()
        try:
            result.success = self._handler.describe_splits(args.cfName, args.start_token, args.end_token, args.keys_per_split)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("describe_splits", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_trace_next_query(self, seqid, iprot, oprot):
        args = trace_next_query_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = trace_next_query_result()
        try:
            result.success = self._handler.trace_next_query()
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("trace_next_query", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_describe_splits_ex(self, seqid, iprot, oprot):
        args = describe_splits_ex_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = describe_splits_ex_result()
        try:
            result.success = self._handler.describe_splits_ex(args.cfName, args.start_token, args.end_token, args.keys_per_split)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("describe_splits_ex", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_system_add_column_family(self, seqid, iprot, oprot):
        args = system_add_column_family_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = system_add_column_family_result()
        try:
            result.success = self._handler.system_add_column_family(args.cf_def)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except SchemaDisagreementException as sde:
            msg_type = TMessageType.REPLY
            result.sde = sde
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("system_add_column_family", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_system_drop_column_family(self, seqid, iprot, oprot):
        args = system_drop_column_family_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = system_drop_column_family_result()
        try:
            result.success = self._handler.system_drop_column_family(args.column_family)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except SchemaDisagreementException as sde:
            msg_type = TMessageType.REPLY
            result.sde = sde
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("system_drop_column_family", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_system_add_keyspace(self, seqid, iprot, oprot):
        args = system_add_keyspace_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = system_add_keyspace_result()
        try:
            result.success = self._handler.system_add_keyspace(args.ks_def)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except SchemaDisagreementException as sde:
            msg_type = TMessageType.REPLY
            result.sde = sde
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("system_add_keyspace", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_system_drop_keyspace(self, seqid, iprot, oprot):
        args = system_drop_keyspace_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = system_drop_keyspace_result()
        try:
            result.success = self._handler.system_drop_keyspace(args.keyspace)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except SchemaDisagreementException as sde:
            msg_type = TMessageType.REPLY
            result.sde = sde
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("system_drop_keyspace", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_system_update_keyspace(self, seqid, iprot, oprot):
        args = system_update_keyspace_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = system_update_keyspace_result()
        try:
            result.success = self._handler.system_update_keyspace(args.ks_def)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except SchemaDisagreementException as sde:
            msg_type = TMessageType.REPLY
            result.sde = sde
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("system_update_keyspace", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_system_update_column_family(self, seqid, iprot, oprot):
        args = system_update_column_family_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = system_update_column_family_result()
        try:
            result.success = self._handler.system_update_column_family(args.cf_def)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except SchemaDisagreementException as sde:
            msg_type = TMessageType.REPLY
            result.sde = sde
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("system_update_column_family", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_execute_cql_query(self, seqid, iprot, oprot):
        args = execute_cql_query_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = execute_cql_query_result()
        try:
            result.success = self._handler.execute_cql_query(args.query, args.compression)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except UnavailableException as ue:
            msg_type = TMessageType.REPLY
            result.ue = ue
        except TimedOutException as te:
            msg_type = TMessageType.REPLY
            result.te = te
        except SchemaDisagreementException as sde:
            msg_type = TMessageType.REPLY
            result.sde = sde
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("execute_cql_query", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_execute_cql3_query(self, seqid, iprot, oprot):
        args = execute_cql3_query_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = execute_cql3_query_result()
        try:
            result.success = self._handler.execute_cql3_query(args.query, args.compression, args.consistency)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except UnavailableException as ue:
            msg_type = TMessageType.REPLY
            result.ue = ue
        except TimedOutException as te:
            msg_type = TMessageType.REPLY
            result.te = te
        except SchemaDisagreementException as sde:
            msg_type = TMessageType.REPLY
            result.sde = sde
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("execute_cql3_query", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_prepare_cql_query(self, seqid, iprot, oprot):
        args = prepare_cql_query_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = prepare_cql_query_result()
        try:
            result.success = self._handler.prepare_cql_query(args.query, args.compression)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("prepare_cql_query", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_prepare_cql3_query(self, seqid, iprot, oprot):
        args = prepare_cql3_query_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = prepare_cql3_query_result()
        try:
            result.success = self._handler.prepare_cql3_query(args.query, args.compression)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("prepare_cql3_query", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_execute_prepared_cql_query(self, seqid, iprot, oprot):
        args = execute_prepared_cql_query_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = execute_prepared_cql_query_result()
        try:
            result.success = self._handler.execute_prepared_cql_query(args.itemId, args.values)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except UnavailableException as ue:
            msg_type = TMessageType.REPLY
            result.ue = ue
        except TimedOutException as te:
            msg_type = TMessageType.REPLY
            result.te = te
        except SchemaDisagreementException as sde:
            msg_type = TMessageType.REPLY
            result.sde = sde
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("execute_prepared_cql_query", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_execute_prepared_cql3_query(self, seqid, iprot, oprot):
        args = execute_prepared_cql3_query_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = execute_prepared_cql3_query_result()
        try:
            result.success = self._handler.execute_prepared_cql3_query(args.itemId, args.values, args.consistency)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except UnavailableException as ue:
            msg_type = TMessageType.REPLY
            result.ue = ue
        except TimedOutException as te:
            msg_type = TMessageType.REPLY
            result.te = te
        except SchemaDisagreementException as sde:
            msg_type = TMessageType.REPLY
            result.sde = sde
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("execute_prepared_cql3_query", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

    def process_set_cql_version(self, seqid, iprot, oprot):
        args = set_cql_version_args()
        args.read(iprot)
        iprot.readMessageEnd()
        result = set_cql_version_result()
        try:
            self._handler.set_cql_version(args.version)
            msg_type = TMessageType.REPLY
        except (TTransport.TTransportException, KeyboardInterrupt, SystemExit):
            raise
        except InvalidRequestException as ire:
            msg_type = TMessageType.REPLY
            result.ire = ire
        except Exception as ex:
            msg_type = TMessageType.EXCEPTION
            logging.exception(ex)
            result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error')
        oprot.writeMessageBegin("set_cql_version", msg_type, seqid)
        result.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()

# HELPER FUNCTIONS AND STRUCTURES


class login_args(object):
    """
    Attributes:
     - auth_request
    """

    thrift_spec = (
        None,  # 0
        (1, TType.STRUCT, 'auth_request', (AuthenticationRequest, AuthenticationRequest.thrift_spec), None, ),  # 1
    )

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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.auth_request = AuthenticationRequest()
                    self.auth_request.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('login_args')
        if self.auth_request is not None:
            oprot.writeFieldBegin('auth_request', TType.STRUCT, 1)
            self.auth_request.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

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

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 login_result(object):
    """
    Attributes:
     - authnx
     - authzx
    """

    thrift_spec = (
        None,  # 0
        (1, TType.STRUCT, 'authnx', (AuthenticationException, AuthenticationException.thrift_spec), None, ),  # 1
        (2, TType.STRUCT, 'authzx', (AuthorizationException, AuthorizationException.thrift_spec), None, ),  # 2
    )

    def __init__(self, authnx=None, authzx=None,):
        self.authnx = authnx
        self.authzx = authzx

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.authnx = AuthenticationException()
                    self.authnx.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.authzx = AuthorizationException()
                    self.authzx.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('login_result')
        if self.authnx is not None:
            oprot.writeFieldBegin('authnx', TType.STRUCT, 1)
            self.authnx.write(oprot)
            oprot.writeFieldEnd()
        if self.authzx is not None:
            oprot.writeFieldBegin('authzx', TType.STRUCT, 2)
            self.authzx.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 set_keyspace_args(object):
    """
    Attributes:
     - keyspace
    """

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

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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.keyspace = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('set_keyspace_args')
        if self.keyspace is not None:
            oprot.writeFieldBegin('keyspace', TType.STRING, 1)
            oprot.writeString(self.keyspace.encode('utf-8') if sys.version_info[0] == 2 else self.keyspace)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

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

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 set_keyspace_result(object):
    """
    Attributes:
     - ire
    """

    thrift_spec = (
        None,  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
    )

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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('set_keyspace_result')
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 get_args(object):
    """
    Attributes:
     - key
     - column_path
     - consistency_level
    """

    thrift_spec = (
        None,  # 0
        (1, TType.STRING, 'key', 'BINARY', None, ),  # 1
        (2, TType.STRUCT, 'column_path', (ColumnPath, ColumnPath.thrift_spec), None, ),  # 2
        (3, TType.I32, 'consistency_level', None, 1, ),  # 3
    )

    def __init__(self, key=None, column_path=None, consistency_level=thrift_spec[3][4],):
        self.key = key
        self.column_path = column_path
        self.consistency_level = consistency_level

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.key = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.column_path = ColumnPath()
                    self.column_path.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.I32:
                    self.consistency_level = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('get_args')
        if self.key is not None:
            oprot.writeFieldBegin('key', TType.STRING, 1)
            oprot.writeBinary(self.key)
            oprot.writeFieldEnd()
        if self.column_path is not None:
            oprot.writeFieldBegin('column_path', TType.STRUCT, 2)
            self.column_path.write(oprot)
            oprot.writeFieldEnd()
        if self.consistency_level is not None:
            oprot.writeFieldBegin('consistency_level', TType.I32, 3)
            oprot.writeI32(self.consistency_level)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

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

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 get_result(object):
    """
    Attributes:
     - success
     - ire
     - nfe
     - ue
     - te
    """

    thrift_spec = (
        (0, TType.STRUCT, 'success', (ColumnOrSuperColumn, ColumnOrSuperColumn.thrift_spec), None, ),  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
        (2, TType.STRUCT, 'nfe', (NotFoundException, NotFoundException.thrift_spec), None, ),  # 2
        (3, TType.STRUCT, 'ue', (UnavailableException, UnavailableException.thrift_spec), None, ),  # 3
        (4, TType.STRUCT, 'te', (TimedOutException, TimedOutException.thrift_spec), None, ),  # 4
    )

    def __init__(self, success=None, ire=None, nfe=None, ue=None, te=None,):
        self.success = success
        self.ire = ire
        self.nfe = nfe
        self.ue = ue
        self.te = te

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = ColumnOrSuperColumn()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.nfe = NotFoundException()
                    self.nfe.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.ue = UnavailableException()
                    self.ue.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.STRUCT:
                    self.te = TimedOutException()
                    self.te.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('get_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        if self.nfe is not None:
            oprot.writeFieldBegin('nfe', TType.STRUCT, 2)
            self.nfe.write(oprot)
            oprot.writeFieldEnd()
        if self.ue is not None:
            oprot.writeFieldBegin('ue', TType.STRUCT, 3)
            self.ue.write(oprot)
            oprot.writeFieldEnd()
        if self.te is not None:
            oprot.writeFieldBegin('te', TType.STRUCT, 4)
            self.te.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 get_slice_args(object):
    """
    Attributes:
     - key
     - column_parent
     - predicate
     - consistency_level
    """

    thrift_spec = (
        None,  # 0
        (1, TType.STRING, 'key', 'BINARY', None, ),  # 1
        (2, TType.STRUCT, 'column_parent', (ColumnParent, ColumnParent.thrift_spec), None, ),  # 2
        (3, TType.STRUCT, 'predicate', (SlicePredicate, SlicePredicate.thrift_spec), None, ),  # 3
        (4, TType.I32, 'consistency_level', None, 1, ),  # 4
    )

    def __init__(self, key=None, column_parent=None, predicate=None, consistency_level=thrift_spec[4][4],):
        self.key = key
        self.column_parent = column_parent
        self.predicate = predicate
        self.consistency_level = consistency_level

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.key = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.column_parent = ColumnParent()
                    self.column_parent.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.predicate = SlicePredicate()
                    self.predicate.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.I32:
                    self.consistency_level = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('get_slice_args')
        if self.key is not None:
            oprot.writeFieldBegin('key', TType.STRING, 1)
            oprot.writeBinary(self.key)
            oprot.writeFieldEnd()
        if self.column_parent is not None:
            oprot.writeFieldBegin('column_parent', TType.STRUCT, 2)
            self.column_parent.write(oprot)
            oprot.writeFieldEnd()
        if self.predicate is not None:
            oprot.writeFieldBegin('predicate', TType.STRUCT, 3)
            self.predicate.write(oprot)
            oprot.writeFieldEnd()
        if self.consistency_level is not None:
            oprot.writeFieldBegin('consistency_level', TType.I32, 4)
            oprot.writeI32(self.consistency_level)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        if self.key is None:
            raise TProtocolException(message='Required field key is unset!')
        if self.column_parent is None:
            raise TProtocolException(message='Required field column_parent is unset!')
        if self.predicate is None:
            raise TProtocolException(message='Required field predicate is unset!')
        if self.consistency_level is None:
            raise TProtocolException(message='Required field consistency_level is unset!')
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 get_slice_result(object):
    """
    Attributes:
     - success
     - ire
     - ue
     - te
    """

    thrift_spec = (
        (0, TType.LIST, 'success', (TType.STRUCT, (ColumnOrSuperColumn, ColumnOrSuperColumn.thrift_spec), False), None, ),  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
        (2, TType.STRUCT, 'ue', (UnavailableException, UnavailableException.thrift_spec), None, ),  # 2
        (3, TType.STRUCT, 'te', (TimedOutException, TimedOutException.thrift_spec), None, ),  # 3
    )

    def __init__(self, success=None, ire=None, ue=None, te=None,):
        self.success = success
        self.ire = ire
        self.ue = ue
        self.te = te

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.LIST:
                    self.success = []
                    (_etype201, _size198) = iprot.readListBegin()
                    for _i202 in range(_size198):
                        _elem203 = ColumnOrSuperColumn()
                        _elem203.read(iprot)
                        self.success.append(_elem203)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ue = UnavailableException()
                    self.ue.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.te = TimedOutException()
                    self.te.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('get_slice_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.LIST, 0)
            oprot.writeListBegin(TType.STRUCT, len(self.success))
            for iter204 in self.success:
                iter204.write(oprot)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        if self.ue is not None:
            oprot.writeFieldBegin('ue', TType.STRUCT, 2)
            self.ue.write(oprot)
            oprot.writeFieldEnd()
        if self.te is not None:
            oprot.writeFieldBegin('te', TType.STRUCT, 3)
            self.te.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 get_count_args(object):
    """
    Attributes:
     - key
     - column_parent
     - predicate
     - consistency_level
    """

    thrift_spec = (
        None,  # 0
        (1, TType.STRING, 'key', 'BINARY', None, ),  # 1
        (2, TType.STRUCT, 'column_parent', (ColumnParent, ColumnParent.thrift_spec), None, ),  # 2
        (3, TType.STRUCT, 'predicate', (SlicePredicate, SlicePredicate.thrift_spec), None, ),  # 3
        (4, TType.I32, 'consistency_level', None, 1, ),  # 4
    )

    def __init__(self, key=None, column_parent=None, predicate=None, consistency_level=thrift_spec[4][4],):
        self.key = key
        self.column_parent = column_parent
        self.predicate = predicate
        self.consistency_level = consistency_level

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.key = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.column_parent = ColumnParent()
                    self.column_parent.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.predicate = SlicePredicate()
                    self.predicate.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.I32:
                    self.consistency_level = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('get_count_args')
        if self.key is not None:
            oprot.writeFieldBegin('key', TType.STRING, 1)
            oprot.writeBinary(self.key)
            oprot.writeFieldEnd()
        if self.column_parent is not None:
            oprot.writeFieldBegin('column_parent', TType.STRUCT, 2)
            self.column_parent.write(oprot)
            oprot.writeFieldEnd()
        if self.predicate is not None:
            oprot.writeFieldBegin('predicate', TType.STRUCT, 3)
            self.predicate.write(oprot)
            oprot.writeFieldEnd()
        if self.consistency_level is not None:
            oprot.writeFieldBegin('consistency_level', TType.I32, 4)
            oprot.writeI32(self.consistency_level)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        if self.key is None:
            raise TProtocolException(message='Required field key is unset!')
        if self.column_parent is None:
            raise TProtocolException(message='Required field column_parent is unset!')
        if self.predicate is None:
            raise TProtocolException(message='Required field predicate is unset!')
        if self.consistency_level is None:
            raise TProtocolException(message='Required field consistency_level is unset!')
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 get_count_result(object):
    """
    Attributes:
     - success
     - ire
     - ue
     - te
    """

    thrift_spec = (
        (0, TType.I32, 'success', None, None, ),  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
        (2, TType.STRUCT, 'ue', (UnavailableException, UnavailableException.thrift_spec), None, ),  # 2
        (3, TType.STRUCT, 'te', (TimedOutException, TimedOutException.thrift_spec), None, ),  # 3
    )

    def __init__(self, success=None, ire=None, ue=None, te=None,):
        self.success = success
        self.ire = ire
        self.ue = ue
        self.te = te

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.I32:
                    self.success = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ue = UnavailableException()
                    self.ue.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.te = TimedOutException()
                    self.te.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('get_count_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.I32, 0)
            oprot.writeI32(self.success)
            oprot.writeFieldEnd()
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        if self.ue is not None:
            oprot.writeFieldBegin('ue', TType.STRUCT, 2)
            self.ue.write(oprot)
            oprot.writeFieldEnd()
        if self.te is not None:
            oprot.writeFieldBegin('te', TType.STRUCT, 3)
            self.te.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 multiget_slice_args(object):
    """
    Attributes:
     - keys
     - column_parent
     - predicate
     - consistency_level
    """

    thrift_spec = (
        None,  # 0
        (1, TType.LIST, 'keys', (TType.STRING, 'BINARY', False), None, ),  # 1
        (2, TType.STRUCT, 'column_parent', (ColumnParent, ColumnParent.thrift_spec), None, ),  # 2
        (3, TType.STRUCT, 'predicate', (SlicePredicate, SlicePredicate.thrift_spec), None, ),  # 3
        (4, TType.I32, 'consistency_level', None, 1, ),  # 4
    )

    def __init__(self, keys=None, column_parent=None, predicate=None, consistency_level=thrift_spec[4][4],):
        self.keys = keys
        self.column_parent = column_parent
        self.predicate = predicate
        self.consistency_level = consistency_level

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.keys = []
                    (_etype208, _size205) = iprot.readListBegin()
                    for _i209 in range(_size205):
                        _elem210 = iprot.readBinary()
                        self.keys.append(_elem210)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.column_parent = ColumnParent()
                    self.column_parent.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.predicate = SlicePredicate()
                    self.predicate.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.I32:
                    self.consistency_level = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('multiget_slice_args')
        if self.keys is not None:
            oprot.writeFieldBegin('keys', TType.LIST, 1)
            oprot.writeListBegin(TType.STRING, len(self.keys))
            for iter211 in self.keys:
                oprot.writeBinary(iter211)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.column_parent is not None:
            oprot.writeFieldBegin('column_parent', TType.STRUCT, 2)
            self.column_parent.write(oprot)
            oprot.writeFieldEnd()
        if self.predicate is not None:
            oprot.writeFieldBegin('predicate', TType.STRUCT, 3)
            self.predicate.write(oprot)
            oprot.writeFieldEnd()
        if self.consistency_level is not None:
            oprot.writeFieldBegin('consistency_level', TType.I32, 4)
            oprot.writeI32(self.consistency_level)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        if self.keys is None:
            raise TProtocolException(message='Required field keys is unset!')
        if self.column_parent is None:
            raise TProtocolException(message='Required field column_parent is unset!')
        if self.predicate is None:
            raise TProtocolException(message='Required field predicate is unset!')
        if self.consistency_level is None:
            raise TProtocolException(message='Required field consistency_level is unset!')
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 multiget_slice_result(object):
    """
    Attributes:
     - success
     - ire
     - ue
     - te
    """

    thrift_spec = (
        (0, TType.MAP, 'success', (TType.STRING, 'BINARY', TType.LIST, (TType.STRUCT, (ColumnOrSuperColumn, ColumnOrSuperColumn.thrift_spec), False), False), None, ),  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
        (2, TType.STRUCT, 'ue', (UnavailableException, UnavailableException.thrift_spec), None, ),  # 2
        (3, TType.STRUCT, 'te', (TimedOutException, TimedOutException.thrift_spec), None, ),  # 3
    )

    def __init__(self, success=None, ire=None, ue=None, te=None,):
        self.success = success
        self.ire = ire
        self.ue = ue
        self.te = te

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.MAP:
                    self.success = {}
                    (_ktype213, _vtype214, _size212) = iprot.readMapBegin()
                    for _i216 in range(_size212):
                        _key217 = iprot.readBinary()
                        _val218 = []
                        (_etype222, _size219) = iprot.readListBegin()
                        for _i223 in range(_size219):
                            _elem224 = ColumnOrSuperColumn()
                            _elem224.read(iprot)
                            _val218.append(_elem224)
                        iprot.readListEnd()
                        self.success[_key217] = _val218
                    iprot.readMapEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ue = UnavailableException()
                    self.ue.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.te = TimedOutException()
                    self.te.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('multiget_slice_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.MAP, 0)
            oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
            for kiter225, viter226 in self.success.items():
                oprot.writeBinary(kiter225)
                oprot.writeListBegin(TType.STRUCT, len(viter226))
                for iter227 in viter226:
                    iter227.write(oprot)
                oprot.writeListEnd()
            oprot.writeMapEnd()
            oprot.writeFieldEnd()
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        if self.ue is not None:
            oprot.writeFieldBegin('ue', TType.STRUCT, 2)
            self.ue.write(oprot)
            oprot.writeFieldEnd()
        if self.te is not None:
            oprot.writeFieldBegin('te', TType.STRUCT, 3)
            self.te.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 multiget_count_args(object):
    """
    Attributes:
     - keys
     - column_parent
     - predicate
     - consistency_level
    """

    thrift_spec = (
        None,  # 0
        (1, TType.LIST, 'keys', (TType.STRING, 'BINARY', False), None, ),  # 1
        (2, TType.STRUCT, 'column_parent', (ColumnParent, ColumnParent.thrift_spec), None, ),  # 2
        (3, TType.STRUCT, 'predicate', (SlicePredicate, SlicePredicate.thrift_spec), None, ),  # 3
        (4, TType.I32, 'consistency_level', None, 1, ),  # 4
    )

    def __init__(self, keys=None, column_parent=None, predicate=None, consistency_level=thrift_spec[4][4],):
        self.keys = keys
        self.column_parent = column_parent
        self.predicate = predicate
        self.consistency_level = consistency_level

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.keys = []
                    (_etype231, _size228) = iprot.readListBegin()
                    for _i232 in range(_size228):
                        _elem233 = iprot.readBinary()
                        self.keys.append(_elem233)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.column_parent = ColumnParent()
                    self.column_parent.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.predicate = SlicePredicate()
                    self.predicate.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.I32:
                    self.consistency_level = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('multiget_count_args')
        if self.keys is not None:
            oprot.writeFieldBegin('keys', TType.LIST, 1)
            oprot.writeListBegin(TType.STRING, len(self.keys))
            for iter234 in self.keys:
                oprot.writeBinary(iter234)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.column_parent is not None:
            oprot.writeFieldBegin('column_parent', TType.STRUCT, 2)
            self.column_parent.write(oprot)
            oprot.writeFieldEnd()
        if self.predicate is not None:
            oprot.writeFieldBegin('predicate', TType.STRUCT, 3)
            self.predicate.write(oprot)
            oprot.writeFieldEnd()
        if self.consistency_level is not None:
            oprot.writeFieldBegin('consistency_level', TType.I32, 4)
            oprot.writeI32(self.consistency_level)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        if self.keys is None:
            raise TProtocolException(message='Required field keys is unset!')
        if self.column_parent is None:
            raise TProtocolException(message='Required field column_parent is unset!')
        if self.predicate is None:
            raise TProtocolException(message='Required field predicate is unset!')
        if self.consistency_level is None:
            raise TProtocolException(message='Required field consistency_level is unset!')
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 multiget_count_result(object):
    """
    Attributes:
     - success
     - ire
     - ue
     - te
    """

    thrift_spec = (
        (0, TType.MAP, 'success', (TType.STRING, 'BINARY', TType.I32, None, False), None, ),  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
        (2, TType.STRUCT, 'ue', (UnavailableException, UnavailableException.thrift_spec), None, ),  # 2
        (3, TType.STRUCT, 'te', (TimedOutException, TimedOutException.thrift_spec), None, ),  # 3
    )

    def __init__(self, success=None, ire=None, ue=None, te=None,):
        self.success = success
        self.ire = ire
        self.ue = ue
        self.te = te

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.MAP:
                    self.success = {}
                    (_ktype236, _vtype237, _size235) = iprot.readMapBegin()
                    for _i239 in range(_size235):
                        _key240 = iprot.readBinary()
                        _val241 = iprot.readI32()
                        self.success[_key240] = _val241
                    iprot.readMapEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ue = UnavailableException()
                    self.ue.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.te = TimedOutException()
                    self.te.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('multiget_count_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.MAP, 0)
            oprot.writeMapBegin(TType.STRING, TType.I32, len(self.success))
            for kiter242, viter243 in self.success.items():
                oprot.writeBinary(kiter242)
                oprot.writeI32(viter243)
            oprot.writeMapEnd()
            oprot.writeFieldEnd()
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        if self.ue is not None:
            oprot.writeFieldBegin('ue', TType.STRUCT, 2)
            self.ue.write(oprot)
            oprot.writeFieldEnd()
        if self.te is not None:
            oprot.writeFieldBegin('te', TType.STRUCT, 3)
            self.te.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 get_range_slices_args(object):
    """
    Attributes:
     - column_parent
     - predicate
     - range
     - consistency_level
    """

    thrift_spec = (
        None,  # 0
        (1, TType.STRUCT, 'column_parent', (ColumnParent, ColumnParent.thrift_spec), None, ),  # 1
        (2, TType.STRUCT, 'predicate', (SlicePredicate, SlicePredicate.thrift_spec), None, ),  # 2
        (3, TType.STRUCT, 'range', (KeyRange, KeyRange.thrift_spec), None, ),  # 3
        (4, TType.I32, 'consistency_level', None, 1, ),  # 4
    )

    def __init__(self, column_parent=None, predicate=None, range=None, consistency_level=thrift_spec[4][4],):
        self.column_parent = column_parent
        self.predicate = predicate
        self.range = range
        self.consistency_level = consistency_level

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.column_parent = ColumnParent()
                    self.column_parent.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.predicate = SlicePredicate()
                    self.predicate.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.range = KeyRange()
                    self.range.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.I32:
                    self.consistency_level = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('get_range_slices_args')
        if self.column_parent is not None:
            oprot.writeFieldBegin('column_parent', TType.STRUCT, 1)
            self.column_parent.write(oprot)
            oprot.writeFieldEnd()
        if self.predicate is not None:
            oprot.writeFieldBegin('predicate', TType.STRUCT, 2)
            self.predicate.write(oprot)
            oprot.writeFieldEnd()
        if self.range is not None:
            oprot.writeFieldBegin('range', TType.STRUCT, 3)
            self.range.write(oprot)
            oprot.writeFieldEnd()
        if self.consistency_level is not None:
            oprot.writeFieldBegin('consistency_level', TType.I32, 4)
            oprot.writeI32(self.consistency_level)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        if self.column_parent is None:
            raise TProtocolException(message='Required field column_parent is unset!')
        if self.predicate is None:
            raise TProtocolException(message='Required field predicate is unset!')
        if self.range is None:
            raise TProtocolException(message='Required field range is unset!')
        if self.consistency_level is None:
            raise TProtocolException(message='Required field consistency_level is unset!')
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 get_range_slices_result(object):
    """
    Attributes:
     - success
     - ire
     - ue
     - te
    """

    thrift_spec = (
        (0, TType.LIST, 'success', (TType.STRUCT, (KeySlice, KeySlice.thrift_spec), False), None, ),  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
        (2, TType.STRUCT, 'ue', (UnavailableException, UnavailableException.thrift_spec), None, ),  # 2
        (3, TType.STRUCT, 'te', (TimedOutException, TimedOutException.thrift_spec), None, ),  # 3
    )

    def __init__(self, success=None, ire=None, ue=None, te=None,):
        self.success = success
        self.ire = ire
        self.ue = ue
        self.te = te

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.LIST:
                    self.success = []
                    (_etype247, _size244) = iprot.readListBegin()
                    for _i248 in range(_size244):
                        _elem249 = KeySlice()
                        _elem249.read(iprot)
                        self.success.append(_elem249)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ue = UnavailableException()
                    self.ue.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.te = TimedOutException()
                    self.te.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('get_range_slices_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.LIST, 0)
            oprot.writeListBegin(TType.STRUCT, len(self.success))
            for iter250 in self.success:
                iter250.write(oprot)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        if self.ue is not None:
            oprot.writeFieldBegin('ue', TType.STRUCT, 2)
            self.ue.write(oprot)
            oprot.writeFieldEnd()
        if self.te is not None:
            oprot.writeFieldBegin('te', TType.STRUCT, 3)
            self.te.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 get_paged_slice_args(object):
    """
    Attributes:
     - column_family
     - range
     - start_column
     - consistency_level
    """

    thrift_spec = (
        None,  # 0
        (1, TType.STRING, 'column_family', 'UTF8', None, ),  # 1
        (2, TType.STRUCT, 'range', (KeyRange, KeyRange.thrift_spec), None, ),  # 2
        (3, TType.STRING, 'start_column', 'BINARY', None, ),  # 3
        (4, TType.I32, 'consistency_level', None, 1, ),  # 4
    )

    def __init__(self, column_family=None, range=None, start_column=None, consistency_level=thrift_spec[4][4],):
        self.column_family = column_family
        self.range = range
        self.start_column = start_column
        self.consistency_level = consistency_level

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.column_family = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.range = KeyRange()
                    self.range.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.start_column = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.I32:
                    self.consistency_level = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('get_paged_slice_args')
        if self.column_family is not None:
            oprot.writeFieldBegin('column_family', TType.STRING, 1)
            oprot.writeString(self.column_family.encode('utf-8') if sys.version_info[0] == 2 else self.column_family)
            oprot.writeFieldEnd()
        if self.range is not None:
            oprot.writeFieldBegin('range', TType.STRUCT, 2)
            self.range.write(oprot)
            oprot.writeFieldEnd()
        if self.start_column is not None:
            oprot.writeFieldBegin('start_column', TType.STRING, 3)
            oprot.writeBinary(self.start_column)
            oprot.writeFieldEnd()
        if self.consistency_level is not None:
            oprot.writeFieldBegin('consistency_level', TType.I32, 4)
            oprot.writeI32(self.consistency_level)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        if self.column_family is None:
            raise TProtocolException(message='Required field column_family is unset!')
        if self.range is None:
            raise TProtocolException(message='Required field range is unset!')
        if self.start_column is None:
            raise TProtocolException(message='Required field start_column is unset!')
        if self.consistency_level is None:
            raise TProtocolException(message='Required field consistency_level is unset!')
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 get_paged_slice_result(object):
    """
    Attributes:
     - success
     - ire
     - ue
     - te
    """

    thrift_spec = (
        (0, TType.LIST, 'success', (TType.STRUCT, (KeySlice, KeySlice.thrift_spec), False), None, ),  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
        (2, TType.STRUCT, 'ue', (UnavailableException, UnavailableException.thrift_spec), None, ),  # 2
        (3, TType.STRUCT, 'te', (TimedOutException, TimedOutException.thrift_spec), None, ),  # 3
    )

    def __init__(self, success=None, ire=None, ue=None, te=None,):
        self.success = success
        self.ire = ire
        self.ue = ue
        self.te = te

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.LIST:
                    self.success = []
                    (_etype254, _size251) = iprot.readListBegin()
                    for _i255 in range(_size251):
                        _elem256 = KeySlice()
                        _elem256.read(iprot)
                        self.success.append(_elem256)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ue = UnavailableException()
                    self.ue.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.te = TimedOutException()
                    self.te.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('get_paged_slice_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.LIST, 0)
            oprot.writeListBegin(TType.STRUCT, len(self.success))
            for iter257 in self.success:
                iter257.write(oprot)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        if self.ue is not None:
            oprot.writeFieldBegin('ue', TType.STRUCT, 2)
            self.ue.write(oprot)
            oprot.writeFieldEnd()
        if self.te is not None:
            oprot.writeFieldBegin('te', TType.STRUCT, 3)
            self.te.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 get_indexed_slices_args(object):
    """
    Attributes:
     - column_parent
     - index_clause
     - column_predicate
     - consistency_level
    """

    thrift_spec = (
        None,  # 0
        (1, TType.STRUCT, 'column_parent', (ColumnParent, ColumnParent.thrift_spec), None, ),  # 1
        (2, TType.STRUCT, 'index_clause', (IndexClause, IndexClause.thrift_spec), None, ),  # 2
        (3, TType.STRUCT, 'column_predicate', (SlicePredicate, SlicePredicate.thrift_spec), None, ),  # 3
        (4, TType.I32, 'consistency_level', None, 1, ),  # 4
    )

    def __init__(self, column_parent=None, index_clause=None, column_predicate=None, consistency_level=thrift_spec[4][4],):
        self.column_parent = column_parent
        self.index_clause = index_clause
        self.column_predicate = column_predicate
        self.consistency_level = consistency_level

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.column_parent = ColumnParent()
                    self.column_parent.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.index_clause = IndexClause()
                    self.index_clause.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.column_predicate = SlicePredicate()
                    self.column_predicate.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.I32:
                    self.consistency_level = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('get_indexed_slices_args')
        if self.column_parent is not None:
            oprot.writeFieldBegin('column_parent', TType.STRUCT, 1)
            self.column_parent.write(oprot)
            oprot.writeFieldEnd()
        if self.index_clause is not None:
            oprot.writeFieldBegin('index_clause', TType.STRUCT, 2)
            self.index_clause.write(oprot)
            oprot.writeFieldEnd()
        if self.column_predicate is not None:
            oprot.writeFieldBegin('column_predicate', TType.STRUCT, 3)
            self.column_predicate.write(oprot)
            oprot.writeFieldEnd()
        if self.consistency_level is not None:
            oprot.writeFieldBegin('consistency_level', TType.I32, 4)
            oprot.writeI32(self.consistency_level)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        if self.column_parent is None:
            raise TProtocolException(message='Required field column_parent is unset!')
        if self.index_clause is None:
            raise TProtocolException(message='Required field index_clause is unset!')
        if self.column_predicate is None:
            raise TProtocolException(message='Required field column_predicate is unset!')
        if self.consistency_level is None:
            raise TProtocolException(message='Required field consistency_level is unset!')
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 get_indexed_slices_result(object):
    """
    Attributes:
     - success
     - ire
     - ue
     - te
    """

    thrift_spec = (
        (0, TType.LIST, 'success', (TType.STRUCT, (KeySlice, KeySlice.thrift_spec), False), None, ),  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
        (2, TType.STRUCT, 'ue', (UnavailableException, UnavailableException.thrift_spec), None, ),  # 2
        (3, TType.STRUCT, 'te', (TimedOutException, TimedOutException.thrift_spec), None, ),  # 3
    )

    def __init__(self, success=None, ire=None, ue=None, te=None,):
        self.success = success
        self.ire = ire
        self.ue = ue
        self.te = te

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.LIST:
                    self.success = []
                    (_etype261, _size258) = iprot.readListBegin()
                    for _i262 in range(_size258):
                        _elem263 = KeySlice()
                        _elem263.read(iprot)
                        self.success.append(_elem263)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ue = UnavailableException()
                    self.ue.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.te = TimedOutException()
                    self.te.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('get_indexed_slices_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.LIST, 0)
            oprot.writeListBegin(TType.STRUCT, len(self.success))
            for iter264 in self.success:
                iter264.write(oprot)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        if self.ue is not None:
            oprot.writeFieldBegin('ue', TType.STRUCT, 2)
            self.ue.write(oprot)
            oprot.writeFieldEnd()
        if self.te is not None:
            oprot.writeFieldBegin('te', TType.STRUCT, 3)
            self.te.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 insert_args(object):
    """
    Attributes:
     - key
     - column_parent
     - column
     - consistency_level
    """

    thrift_spec = (
        None,  # 0
        (1, TType.STRING, 'key', 'BINARY', None, ),  # 1
        (2, TType.STRUCT, 'column_parent', (ColumnParent, ColumnParent.thrift_spec), None, ),  # 2
        (3, TType.STRUCT, 'column', (Column, Column.thrift_spec), None, ),  # 3
        (4, TType.I32, 'consistency_level', None, 1, ),  # 4
    )

    def __init__(self, key=None, column_parent=None, column=None, consistency_level=thrift_spec[4][4],):
        self.key = key
        self.column_parent = column_parent
        self.column = column
        self.consistency_level = consistency_level

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.key = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.column_parent = ColumnParent()
                    self.column_parent.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.column = Column()
                    self.column.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.I32:
                    self.consistency_level = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('insert_args')
        if self.key is not None:
            oprot.writeFieldBegin('key', TType.STRING, 1)
            oprot.writeBinary(self.key)
            oprot.writeFieldEnd()
        if self.column_parent is not None:
            oprot.writeFieldBegin('column_parent', TType.STRUCT, 2)
            self.column_parent.write(oprot)
            oprot.writeFieldEnd()
        if self.column is not None:
            oprot.writeFieldBegin('column', TType.STRUCT, 3)
            self.column.write(oprot)
            oprot.writeFieldEnd()
        if self.consistency_level is not None:
            oprot.writeFieldBegin('consistency_level', TType.I32, 4)
            oprot.writeI32(self.consistency_level)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        if self.key is None:
            raise TProtocolException(message='Required field key is unset!')
        if self.column_parent is None:
            raise TProtocolException(message='Required field column_parent is unset!')
        if self.column is None:
            raise TProtocolException(message='Required field column is unset!')
        if self.consistency_level is None:
            raise TProtocolException(message='Required field consistency_level is unset!')
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 insert_result(object):
    """
    Attributes:
     - ire
     - ue
     - te
    """

    thrift_spec = (
        None,  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
        (2, TType.STRUCT, 'ue', (UnavailableException, UnavailableException.thrift_spec), None, ),  # 2
        (3, TType.STRUCT, 'te', (TimedOutException, TimedOutException.thrift_spec), None, ),  # 3
    )

    def __init__(self, ire=None, ue=None, te=None,):
        self.ire = ire
        self.ue = ue
        self.te = te

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ue = UnavailableException()
                    self.ue.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.te = TimedOutException()
                    self.te.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('insert_result')
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        if self.ue is not None:
            oprot.writeFieldBegin('ue', TType.STRUCT, 2)
            self.ue.write(oprot)
            oprot.writeFieldEnd()
        if self.te is not None:
            oprot.writeFieldBegin('te', TType.STRUCT, 3)
            self.te.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 add_args(object):
    """
    Attributes:
     - key
     - column_parent
     - column
     - consistency_level
    """

    thrift_spec = (
        None,  # 0
        (1, TType.STRING, 'key', 'BINARY', None, ),  # 1
        (2, TType.STRUCT, 'column_parent', (ColumnParent, ColumnParent.thrift_spec), None, ),  # 2
        (3, TType.STRUCT, 'column', (CounterColumn, CounterColumn.thrift_spec), None, ),  # 3
        (4, TType.I32, 'consistency_level', None, 1, ),  # 4
    )

    def __init__(self, key=None, column_parent=None, column=None, consistency_level=thrift_spec[4][4],):
        self.key = key
        self.column_parent = column_parent
        self.column = column
        self.consistency_level = consistency_level

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.key = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.column_parent = ColumnParent()
                    self.column_parent.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.column = CounterColumn()
                    self.column.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.I32:
                    self.consistency_level = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('add_args')
        if self.key is not None:
            oprot.writeFieldBegin('key', TType.STRING, 1)
            oprot.writeBinary(self.key)
            oprot.writeFieldEnd()
        if self.column_parent is not None:
            oprot.writeFieldBegin('column_parent', TType.STRUCT, 2)
            self.column_parent.write(oprot)
            oprot.writeFieldEnd()
        if self.column is not None:
            oprot.writeFieldBegin('column', TType.STRUCT, 3)
            self.column.write(oprot)
            oprot.writeFieldEnd()
        if self.consistency_level is not None:
            oprot.writeFieldBegin('consistency_level', TType.I32, 4)
            oprot.writeI32(self.consistency_level)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        if self.key is None:
            raise TProtocolException(message='Required field key is unset!')
        if self.column_parent is None:
            raise TProtocolException(message='Required field column_parent is unset!')
        if self.column is None:
            raise TProtocolException(message='Required field column is unset!')
        if self.consistency_level is None:
            raise TProtocolException(message='Required field consistency_level is unset!')
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 add_result(object):
    """
    Attributes:
     - ire
     - ue
     - te
    """

    thrift_spec = (
        None,  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
        (2, TType.STRUCT, 'ue', (UnavailableException, UnavailableException.thrift_spec), None, ),  # 2
        (3, TType.STRUCT, 'te', (TimedOutException, TimedOutException.thrift_spec), None, ),  # 3
    )

    def __init__(self, ire=None, ue=None, te=None,):
        self.ire = ire
        self.ue = ue
        self.te = te

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ue = UnavailableException()
                    self.ue.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.te = TimedOutException()
                    self.te.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('add_result')
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        if self.ue is not None:
            oprot.writeFieldBegin('ue', TType.STRUCT, 2)
            self.ue.write(oprot)
            oprot.writeFieldEnd()
        if self.te is not None:
            oprot.writeFieldBegin('te', TType.STRUCT, 3)
            self.te.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 cas_args(object):
    """
    Attributes:
     - key
     - column_family
     - expected
     - updates
     - serial_consistency_level
     - commit_consistency_level
    """

    thrift_spec = (
        None,  # 0
        (1, TType.STRING, 'key', 'BINARY', None, ),  # 1
        (2, TType.STRING, 'column_family', 'UTF8', None, ),  # 2
        (3, TType.LIST, 'expected', (TType.STRUCT, (Column, Column.thrift_spec), False), None, ),  # 3
        (4, TType.LIST, 'updates', (TType.STRUCT, (Column, Column.thrift_spec), False), None, ),  # 4
        (5, TType.I32, 'serial_consistency_level', None, 9, ),  # 5
        (6, TType.I32, 'commit_consistency_level', None, 2, ),  # 6
    )

    def __init__(self, key=None, column_family=None, expected=None, updates=None, serial_consistency_level=thrift_spec[5][4], commit_consistency_level=thrift_spec[6][4],):
        self.key = key
        self.column_family = column_family
        self.expected = expected
        self.updates = updates
        self.serial_consistency_level = serial_consistency_level
        self.commit_consistency_level = commit_consistency_level

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.key = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.column_family = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.LIST:
                    self.expected = []
                    (_etype268, _size265) = iprot.readListBegin()
                    for _i269 in range(_size265):
                        _elem270 = Column()
                        _elem270.read(iprot)
                        self.expected.append(_elem270)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.LIST:
                    self.updates = []
                    (_etype274, _size271) = iprot.readListBegin()
                    for _i275 in range(_size271):
                        _elem276 = Column()
                        _elem276.read(iprot)
                        self.updates.append(_elem276)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 5:
                if ftype == TType.I32:
                    self.serial_consistency_level = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 6:
                if ftype == TType.I32:
                    self.commit_consistency_level = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('cas_args')
        if self.key is not None:
            oprot.writeFieldBegin('key', TType.STRING, 1)
            oprot.writeBinary(self.key)
            oprot.writeFieldEnd()
        if self.column_family is not None:
            oprot.writeFieldBegin('column_family', TType.STRING, 2)
            oprot.writeString(self.column_family.encode('utf-8') if sys.version_info[0] == 2 else self.column_family)
            oprot.writeFieldEnd()
        if self.expected is not None:
            oprot.writeFieldBegin('expected', TType.LIST, 3)
            oprot.writeListBegin(TType.STRUCT, len(self.expected))
            for iter277 in self.expected:
                iter277.write(oprot)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.updates is not None:
            oprot.writeFieldBegin('updates', TType.LIST, 4)
            oprot.writeListBegin(TType.STRUCT, len(self.updates))
            for iter278 in self.updates:
                iter278.write(oprot)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.serial_consistency_level is not None:
            oprot.writeFieldBegin('serial_consistency_level', TType.I32, 5)
            oprot.writeI32(self.serial_consistency_level)
            oprot.writeFieldEnd()
        if self.commit_consistency_level is not None:
            oprot.writeFieldBegin('commit_consistency_level', TType.I32, 6)
            oprot.writeI32(self.commit_consistency_level)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        if self.key is None:
            raise TProtocolException(message='Required field key is unset!')
        if self.column_family is None:
            raise TProtocolException(message='Required field column_family is unset!')
        if self.serial_consistency_level is None:
            raise TProtocolException(message='Required field serial_consistency_level is unset!')
        if self.commit_consistency_level is None:
            raise TProtocolException(message='Required field commit_consistency_level is unset!')
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 cas_result(object):
    """
    Attributes:
     - success
     - ire
     - ue
     - te
    """

    thrift_spec = (
        (0, TType.STRUCT, 'success', (CASResult, CASResult.thrift_spec), None, ),  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
        (2, TType.STRUCT, 'ue', (UnavailableException, UnavailableException.thrift_spec), None, ),  # 2
        (3, TType.STRUCT, 'te', (TimedOutException, TimedOutException.thrift_spec), None, ),  # 3
    )

    def __init__(self, success=None, ire=None, ue=None, te=None,):
        self.success = success
        self.ire = ire
        self.ue = ue
        self.te = te

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = CASResult()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ue = UnavailableException()
                    self.ue.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.te = TimedOutException()
                    self.te.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('cas_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        if self.ue is not None:
            oprot.writeFieldBegin('ue', TType.STRUCT, 2)
            self.ue.write(oprot)
            oprot.writeFieldEnd()
        if self.te is not None:
            oprot.writeFieldBegin('te', TType.STRUCT, 3)
            self.te.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 remove_args(object):
    """
    Attributes:
     - key
     - column_path
     - timestamp
     - consistency_level
    """

    thrift_spec = (
        None,  # 0
        (1, TType.STRING, 'key', 'BINARY', None, ),  # 1
        (2, TType.STRUCT, 'column_path', (ColumnPath, ColumnPath.thrift_spec), None, ),  # 2
        (3, TType.I64, 'timestamp', None, None, ),  # 3
        (4, TType.I32, 'consistency_level', None, 1, ),  # 4
    )

    def __init__(self, key=None, column_path=None, timestamp=None, consistency_level=thrift_spec[4][4],):
        self.key = key
        self.column_path = column_path
        self.timestamp = timestamp
        self.consistency_level = consistency_level

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.key = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.column_path = ColumnPath()
                    self.column_path.read(iprot)
                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.consistency_level = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('remove_args')
        if self.key is not None:
            oprot.writeFieldBegin('key', TType.STRING, 1)
            oprot.writeBinary(self.key)
            oprot.writeFieldEnd()
        if self.column_path is not None:
            oprot.writeFieldBegin('column_path', TType.STRUCT, 2)
            self.column_path.write(oprot)
            oprot.writeFieldEnd()
        if self.timestamp is not None:
            oprot.writeFieldBegin('timestamp', TType.I64, 3)
            oprot.writeI64(self.timestamp)
            oprot.writeFieldEnd()
        if self.consistency_level is not None:
            oprot.writeFieldBegin('consistency_level', TType.I32, 4)
            oprot.writeI32(self.consistency_level)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

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

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 remove_result(object):
    """
    Attributes:
     - ire
     - ue
     - te
    """

    thrift_spec = (
        None,  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
        (2, TType.STRUCT, 'ue', (UnavailableException, UnavailableException.thrift_spec), None, ),  # 2
        (3, TType.STRUCT, 'te', (TimedOutException, TimedOutException.thrift_spec), None, ),  # 3
    )

    def __init__(self, ire=None, ue=None, te=None,):
        self.ire = ire
        self.ue = ue
        self.te = te

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ue = UnavailableException()
                    self.ue.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.te = TimedOutException()
                    self.te.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('remove_result')
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        if self.ue is not None:
            oprot.writeFieldBegin('ue', TType.STRUCT, 2)
            self.ue.write(oprot)
            oprot.writeFieldEnd()
        if self.te is not None:
            oprot.writeFieldBegin('te', TType.STRUCT, 3)
            self.te.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 remove_counter_args(object):
    """
    Attributes:
     - key
     - path
     - consistency_level
    """

    thrift_spec = (
        None,  # 0
        (1, TType.STRING, 'key', 'BINARY', None, ),  # 1
        (2, TType.STRUCT, 'path', (ColumnPath, ColumnPath.thrift_spec), None, ),  # 2
        (3, TType.I32, 'consistency_level', None, 1, ),  # 3
    )

    def __init__(self, key=None, path=None, consistency_level=thrift_spec[3][4],):
        self.key = key
        self.path = path
        self.consistency_level = consistency_level

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.key = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.path = ColumnPath()
                    self.path.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.I32:
                    self.consistency_level = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('remove_counter_args')
        if self.key is not None:
            oprot.writeFieldBegin('key', TType.STRING, 1)
            oprot.writeBinary(self.key)
            oprot.writeFieldEnd()
        if self.path is not None:
            oprot.writeFieldBegin('path', TType.STRUCT, 2)
            self.path.write(oprot)
            oprot.writeFieldEnd()
        if self.consistency_level is not None:
            oprot.writeFieldBegin('consistency_level', TType.I32, 3)
            oprot.writeI32(self.consistency_level)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

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

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 remove_counter_result(object):
    """
    Attributes:
     - ire
     - ue
     - te
    """

    thrift_spec = (
        None,  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
        (2, TType.STRUCT, 'ue', (UnavailableException, UnavailableException.thrift_spec), None, ),  # 2
        (3, TType.STRUCT, 'te', (TimedOutException, TimedOutException.thrift_spec), None, ),  # 3
    )

    def __init__(self, ire=None, ue=None, te=None,):
        self.ire = ire
        self.ue = ue
        self.te = te

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ue = UnavailableException()
                    self.ue.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.te = TimedOutException()
                    self.te.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('remove_counter_result')
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        if self.ue is not None:
            oprot.writeFieldBegin('ue', TType.STRUCT, 2)
            self.ue.write(oprot)
            oprot.writeFieldEnd()
        if self.te is not None:
            oprot.writeFieldBegin('te', TType.STRUCT, 3)
            self.te.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 batch_mutate_args(object):
    """
    Attributes:
     - mutation_map
     - consistency_level
    """

    thrift_spec = (
        None,  # 0
        (1, TType.MAP, 'mutation_map', (TType.STRING, 'BINARY', TType.MAP, (TType.STRING, 'UTF8', TType.LIST, (TType.STRUCT, (Mutation, Mutation.thrift_spec), False), False), False), None, ),  # 1
        (2, TType.I32, 'consistency_level', None, 1, ),  # 2
    )

    def __init__(self, mutation_map=None, consistency_level=thrift_spec[2][4],):
        self.mutation_map = mutation_map
        self.consistency_level = consistency_level

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.MAP:
                    self.mutation_map = {}
                    (_ktype280, _vtype281, _size279) = iprot.readMapBegin()
                    for _i283 in range(_size279):
                        _key284 = iprot.readBinary()
                        _val285 = {}
                        (_ktype287, _vtype288, _size286) = iprot.readMapBegin()
                        for _i290 in range(_size286):
                            _key291 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                            _val292 = []
                            (_etype296, _size293) = iprot.readListBegin()
                            for _i297 in range(_size293):
                                _elem298 = Mutation()
                                _elem298.read(iprot)
                                _val292.append(_elem298)
                            iprot.readListEnd()
                            _val285[_key291] = _val292
                        iprot.readMapEnd()
                        self.mutation_map[_key284] = _val285
                    iprot.readMapEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.I32:
                    self.consistency_level = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('batch_mutate_args')
        if self.mutation_map is not None:
            oprot.writeFieldBegin('mutation_map', TType.MAP, 1)
            oprot.writeMapBegin(TType.STRING, TType.MAP, len(self.mutation_map))
            for kiter299, viter300 in self.mutation_map.items():
                oprot.writeBinary(kiter299)
                oprot.writeMapBegin(TType.STRING, TType.LIST, len(viter300))
                for kiter301, viter302 in viter300.items():
                    oprot.writeString(kiter301.encode('utf-8') if sys.version_info[0] == 2 else kiter301)
                    oprot.writeListBegin(TType.STRUCT, len(viter302))
                    for iter303 in viter302:
                        iter303.write(oprot)
                    oprot.writeListEnd()
                oprot.writeMapEnd()
            oprot.writeMapEnd()
            oprot.writeFieldEnd()
        if self.consistency_level is not None:
            oprot.writeFieldBegin('consistency_level', TType.I32, 2)
            oprot.writeI32(self.consistency_level)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

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

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 batch_mutate_result(object):
    """
    Attributes:
     - ire
     - ue
     - te
    """

    thrift_spec = (
        None,  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
        (2, TType.STRUCT, 'ue', (UnavailableException, UnavailableException.thrift_spec), None, ),  # 2
        (3, TType.STRUCT, 'te', (TimedOutException, TimedOutException.thrift_spec), None, ),  # 3
    )

    def __init__(self, ire=None, ue=None, te=None,):
        self.ire = ire
        self.ue = ue
        self.te = te

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ue = UnavailableException()
                    self.ue.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.te = TimedOutException()
                    self.te.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('batch_mutate_result')
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        if self.ue is not None:
            oprot.writeFieldBegin('ue', TType.STRUCT, 2)
            self.ue.write(oprot)
            oprot.writeFieldEnd()
        if self.te is not None:
            oprot.writeFieldBegin('te', TType.STRUCT, 3)
            self.te.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 atomic_batch_mutate_args(object):
    """
    Attributes:
     - mutation_map
     - consistency_level
    """

    thrift_spec = (
        None,  # 0
        (1, TType.MAP, 'mutation_map', (TType.STRING, 'BINARY', TType.MAP, (TType.STRING, 'UTF8', TType.LIST, (TType.STRUCT, (Mutation, Mutation.thrift_spec), False), False), False), None, ),  # 1
        (2, TType.I32, 'consistency_level', None, 1, ),  # 2
    )

    def __init__(self, mutation_map=None, consistency_level=thrift_spec[2][4],):
        self.mutation_map = mutation_map
        self.consistency_level = consistency_level

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.MAP:
                    self.mutation_map = {}
                    (_ktype305, _vtype306, _size304) = iprot.readMapBegin()
                    for _i308 in range(_size304):
                        _key309 = iprot.readBinary()
                        _val310 = {}
                        (_ktype312, _vtype313, _size311) = iprot.readMapBegin()
                        for _i315 in range(_size311):
                            _key316 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                            _val317 = []
                            (_etype321, _size318) = iprot.readListBegin()
                            for _i322 in range(_size318):
                                _elem323 = Mutation()
                                _elem323.read(iprot)
                                _val317.append(_elem323)
                            iprot.readListEnd()
                            _val310[_key316] = _val317
                        iprot.readMapEnd()
                        self.mutation_map[_key309] = _val310
                    iprot.readMapEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.I32:
                    self.consistency_level = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('atomic_batch_mutate_args')
        if self.mutation_map is not None:
            oprot.writeFieldBegin('mutation_map', TType.MAP, 1)
            oprot.writeMapBegin(TType.STRING, TType.MAP, len(self.mutation_map))
            for kiter324, viter325 in self.mutation_map.items():
                oprot.writeBinary(kiter324)
                oprot.writeMapBegin(TType.STRING, TType.LIST, len(viter325))
                for kiter326, viter327 in viter325.items():
                    oprot.writeString(kiter326.encode('utf-8') if sys.version_info[0] == 2 else kiter326)
                    oprot.writeListBegin(TType.STRUCT, len(viter327))
                    for iter328 in viter327:
                        iter328.write(oprot)
                    oprot.writeListEnd()
                oprot.writeMapEnd()
            oprot.writeMapEnd()
            oprot.writeFieldEnd()
        if self.consistency_level is not None:
            oprot.writeFieldBegin('consistency_level', TType.I32, 2)
            oprot.writeI32(self.consistency_level)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

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

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 atomic_batch_mutate_result(object):
    """
    Attributes:
     - ire
     - ue
     - te
    """

    thrift_spec = (
        None,  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
        (2, TType.STRUCT, 'ue', (UnavailableException, UnavailableException.thrift_spec), None, ),  # 2
        (3, TType.STRUCT, 'te', (TimedOutException, TimedOutException.thrift_spec), None, ),  # 3
    )

    def __init__(self, ire=None, ue=None, te=None,):
        self.ire = ire
        self.ue = ue
        self.te = te

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ue = UnavailableException()
                    self.ue.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.te = TimedOutException()
                    self.te.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('atomic_batch_mutate_result')
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        if self.ue is not None:
            oprot.writeFieldBegin('ue', TType.STRUCT, 2)
            self.ue.write(oprot)
            oprot.writeFieldEnd()
        if self.te is not None:
            oprot.writeFieldBegin('te', TType.STRUCT, 3)
            self.te.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 truncate_args(object):
    """
    Attributes:
     - cfname
    """

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

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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.cfname = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('truncate_args')
        if self.cfname is not None:
            oprot.writeFieldBegin('cfname', TType.STRING, 1)
            oprot.writeString(self.cfname.encode('utf-8') if sys.version_info[0] == 2 else self.cfname)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

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

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 truncate_result(object):
    """
    Attributes:
     - ire
     - ue
     - te
    """

    thrift_spec = (
        None,  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
        (2, TType.STRUCT, 'ue', (UnavailableException, UnavailableException.thrift_spec), None, ),  # 2
        (3, TType.STRUCT, 'te', (TimedOutException, TimedOutException.thrift_spec), None, ),  # 3
    )

    def __init__(self, ire=None, ue=None, te=None,):
        self.ire = ire
        self.ue = ue
        self.te = te

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ue = UnavailableException()
                    self.ue.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.te = TimedOutException()
                    self.te.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('truncate_result')
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        if self.ue is not None:
            oprot.writeFieldBegin('ue', TType.STRUCT, 2)
            self.ue.write(oprot)
            oprot.writeFieldEnd()
        if self.te is not None:
            oprot.writeFieldBegin('te', TType.STRUCT, 3)
            self.te.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 get_multi_slice_args(object):
    """
    Attributes:
     - request
    """

    thrift_spec = (
        None,  # 0
        (1, TType.STRUCT, 'request', (MultiSliceRequest, MultiSliceRequest.thrift_spec), None, ),  # 1
    )

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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.request = MultiSliceRequest()
                    self.request.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('get_multi_slice_args')
        if self.request is not None:
            oprot.writeFieldBegin('request', TType.STRUCT, 1)
            self.request.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

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

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 get_multi_slice_result(object):
    """
    Attributes:
     - success
     - ire
     - ue
     - te
    """

    thrift_spec = (
        (0, TType.LIST, 'success', (TType.STRUCT, (ColumnOrSuperColumn, ColumnOrSuperColumn.thrift_spec), False), None, ),  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
        (2, TType.STRUCT, 'ue', (UnavailableException, UnavailableException.thrift_spec), None, ),  # 2
        (3, TType.STRUCT, 'te', (TimedOutException, TimedOutException.thrift_spec), None, ),  # 3
    )

    def __init__(self, success=None, ire=None, ue=None, te=None,):
        self.success = success
        self.ire = ire
        self.ue = ue
        self.te = te

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.LIST:
                    self.success = []
                    (_etype332, _size329) = iprot.readListBegin()
                    for _i333 in range(_size329):
                        _elem334 = ColumnOrSuperColumn()
                        _elem334.read(iprot)
                        self.success.append(_elem334)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ue = UnavailableException()
                    self.ue.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.te = TimedOutException()
                    self.te.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('get_multi_slice_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.LIST, 0)
            oprot.writeListBegin(TType.STRUCT, len(self.success))
            for iter335 in self.success:
                iter335.write(oprot)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        if self.ue is not None:
            oprot.writeFieldBegin('ue', TType.STRUCT, 2)
            self.ue.write(oprot)
            oprot.writeFieldEnd()
        if self.te is not None:
            oprot.writeFieldBegin('te', TType.STRUCT, 3)
            self.te.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 describe_schema_versions_args(object):

    thrift_spec = (
    )

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('describe_schema_versions_args')
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 describe_schema_versions_result(object):
    """
    Attributes:
     - success
     - ire
    """

    thrift_spec = (
        (0, TType.MAP, 'success', (TType.STRING, 'UTF8', TType.LIST, (TType.STRING, 'UTF8', False), False), None, ),  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
    )

    def __init__(self, success=None, ire=None,):
        self.success = success
        self.ire = ire

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.MAP:
                    self.success = {}
                    (_ktype337, _vtype338, _size336) = iprot.readMapBegin()
                    for _i340 in range(_size336):
                        _key341 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                        _val342 = []
                        (_etype346, _size343) = iprot.readListBegin()
                        for _i347 in range(_size343):
                            _elem348 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                            _val342.append(_elem348)
                        iprot.readListEnd()
                        self.success[_key341] = _val342
                    iprot.readMapEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('describe_schema_versions_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.MAP, 0)
            oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
            for kiter349, viter350 in self.success.items():
                oprot.writeString(kiter349.encode('utf-8') if sys.version_info[0] == 2 else kiter349)
                oprot.writeListBegin(TType.STRING, len(viter350))
                for iter351 in viter350:
                    oprot.writeString(iter351.encode('utf-8') if sys.version_info[0] == 2 else iter351)
                oprot.writeListEnd()
            oprot.writeMapEnd()
            oprot.writeFieldEnd()
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 describe_keyspaces_args(object):

    thrift_spec = (
    )

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('describe_keyspaces_args')
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 describe_keyspaces_result(object):
    """
    Attributes:
     - success
     - ire
    """

    thrift_spec = (
        (0, TType.LIST, 'success', (TType.STRUCT, (KsDef, KsDef.thrift_spec), False), None, ),  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
    )

    def __init__(self, success=None, ire=None,):
        self.success = success
        self.ire = ire

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.LIST:
                    self.success = []
                    (_etype355, _size352) = iprot.readListBegin()
                    for _i356 in range(_size352):
                        _elem357 = KsDef()
                        _elem357.read(iprot)
                        self.success.append(_elem357)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('describe_keyspaces_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.LIST, 0)
            oprot.writeListBegin(TType.STRUCT, len(self.success))
            for iter358 in self.success:
                iter358.write(oprot)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 describe_cluster_name_args(object):

    thrift_spec = (
    )

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('describe_cluster_name_args')
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 describe_cluster_name_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (0, TType.STRING, 'success', 'UTF8', None, ),  # 0
    )

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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRING:
                    self.success = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('describe_cluster_name_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.STRING, 0)
            oprot.writeString(self.success.encode('utf-8') if sys.version_info[0] == 2 else self.success)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 describe_version_args(object):

    thrift_spec = (
    )

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('describe_version_args')
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 describe_version_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (0, TType.STRING, 'success', 'UTF8', None, ),  # 0
    )

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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRING:
                    self.success = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('describe_version_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.STRING, 0)
            oprot.writeString(self.success.encode('utf-8') if sys.version_info[0] == 2 else self.success)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 describe_ring_args(object):
    """
    Attributes:
     - keyspace
    """

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

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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.keyspace = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('describe_ring_args')
        if self.keyspace is not None:
            oprot.writeFieldBegin('keyspace', TType.STRING, 1)
            oprot.writeString(self.keyspace.encode('utf-8') if sys.version_info[0] == 2 else self.keyspace)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

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

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 describe_ring_result(object):
    """
    Attributes:
     - success
     - ire
    """

    thrift_spec = (
        (0, TType.LIST, 'success', (TType.STRUCT, (TokenRange, TokenRange.thrift_spec), False), None, ),  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
    )

    def __init__(self, success=None, ire=None,):
        self.success = success
        self.ire = ire

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.LIST:
                    self.success = []
                    (_etype362, _size359) = iprot.readListBegin()
                    for _i363 in range(_size359):
                        _elem364 = TokenRange()
                        _elem364.read(iprot)
                        self.success.append(_elem364)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('describe_ring_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.LIST, 0)
            oprot.writeListBegin(TType.STRUCT, len(self.success))
            for iter365 in self.success:
                iter365.write(oprot)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 describe_local_ring_args(object):
    """
    Attributes:
     - keyspace
    """

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

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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.keyspace = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('describe_local_ring_args')
        if self.keyspace is not None:
            oprot.writeFieldBegin('keyspace', TType.STRING, 1)
            oprot.writeString(self.keyspace.encode('utf-8') if sys.version_info[0] == 2 else self.keyspace)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

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

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 describe_local_ring_result(object):
    """
    Attributes:
     - success
     - ire
    """

    thrift_spec = (
        (0, TType.LIST, 'success', (TType.STRUCT, (TokenRange, TokenRange.thrift_spec), False), None, ),  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
    )

    def __init__(self, success=None, ire=None,):
        self.success = success
        self.ire = ire

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.LIST:
                    self.success = []
                    (_etype369, _size366) = iprot.readListBegin()
                    for _i370 in range(_size366):
                        _elem371 = TokenRange()
                        _elem371.read(iprot)
                        self.success.append(_elem371)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('describe_local_ring_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.LIST, 0)
            oprot.writeListBegin(TType.STRUCT, len(self.success))
            for iter372 in self.success:
                iter372.write(oprot)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 describe_token_map_args(object):

    thrift_spec = (
    )

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('describe_token_map_args')
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 describe_token_map_result(object):
    """
    Attributes:
     - success
     - ire
    """

    thrift_spec = (
        (0, TType.MAP, 'success', (TType.STRING, 'UTF8', TType.STRING, 'UTF8', False), None, ),  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
    )

    def __init__(self, success=None, ire=None,):
        self.success = success
        self.ire = ire

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.MAP:
                    self.success = {}
                    (_ktype374, _vtype375, _size373) = iprot.readMapBegin()
                    for _i377 in range(_size373):
                        _key378 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                        _val379 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                        self.success[_key378] = _val379
                    iprot.readMapEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('describe_token_map_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.MAP, 0)
            oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
            for kiter380, viter381 in self.success.items():
                oprot.writeString(kiter380.encode('utf-8') if sys.version_info[0] == 2 else kiter380)
                oprot.writeString(viter381.encode('utf-8') if sys.version_info[0] == 2 else viter381)
            oprot.writeMapEnd()
            oprot.writeFieldEnd()
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 describe_partitioner_args(object):

    thrift_spec = (
    )

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('describe_partitioner_args')
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 describe_partitioner_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (0, TType.STRING, 'success', 'UTF8', None, ),  # 0
    )

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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRING:
                    self.success = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('describe_partitioner_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.STRING, 0)
            oprot.writeString(self.success.encode('utf-8') if sys.version_info[0] == 2 else self.success)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 describe_snitch_args(object):

    thrift_spec = (
    )

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('describe_snitch_args')
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 describe_snitch_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (0, TType.STRING, 'success', 'UTF8', None, ),  # 0
    )

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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRING:
                    self.success = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('describe_snitch_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.STRING, 0)
            oprot.writeString(self.success.encode('utf-8') if sys.version_info[0] == 2 else self.success)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 describe_keyspace_args(object):
    """
    Attributes:
     - keyspace
    """

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

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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.keyspace = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('describe_keyspace_args')
        if self.keyspace is not None:
            oprot.writeFieldBegin('keyspace', TType.STRING, 1)
            oprot.writeString(self.keyspace.encode('utf-8') if sys.version_info[0] == 2 else self.keyspace)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

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

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 describe_keyspace_result(object):
    """
    Attributes:
     - success
     - nfe
     - ire
    """

    thrift_spec = (
        (0, TType.STRUCT, 'success', (KsDef, KsDef.thrift_spec), None, ),  # 0
        (1, TType.STRUCT, 'nfe', (NotFoundException, NotFoundException.thrift_spec), None, ),  # 1
        (2, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 2
    )

    def __init__(self, success=None, nfe=None, ire=None,):
        self.success = success
        self.nfe = nfe
        self.ire = ire

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = KsDef()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.nfe = NotFoundException()
                    self.nfe.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('describe_keyspace_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        if self.nfe is not None:
            oprot.writeFieldBegin('nfe', TType.STRUCT, 1)
            self.nfe.write(oprot)
            oprot.writeFieldEnd()
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 2)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 describe_splits_args(object):
    """
    Attributes:
     - cfName
     - start_token
     - end_token
     - keys_per_split
    """

    thrift_spec = (
        None,  # 0
        (1, TType.STRING, 'cfName', 'UTF8', None, ),  # 1
        (2, TType.STRING, 'start_token', 'UTF8', None, ),  # 2
        (3, TType.STRING, 'end_token', 'UTF8', None, ),  # 3
        (4, TType.I32, 'keys_per_split', None, None, ),  # 4
    )

    def __init__(self, cfName=None, start_token=None, end_token=None, keys_per_split=None,):
        self.cfName = cfName
        self.start_token = start_token
        self.end_token = end_token
        self.keys_per_split = keys_per_split

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.cfName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.start_token = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.end_token = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.I32:
                    self.keys_per_split = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('describe_splits_args')
        if self.cfName is not None:
            oprot.writeFieldBegin('cfName', TType.STRING, 1)
            oprot.writeString(self.cfName.encode('utf-8') if sys.version_info[0] == 2 else self.cfName)
            oprot.writeFieldEnd()
        if self.start_token is not None:
            oprot.writeFieldBegin('start_token', TType.STRING, 2)
            oprot.writeString(self.start_token.encode('utf-8') if sys.version_info[0] == 2 else self.start_token)
            oprot.writeFieldEnd()
        if self.end_token is not None:
            oprot.writeFieldBegin('end_token', TType.STRING, 3)
            oprot.writeString(self.end_token.encode('utf-8') if sys.version_info[0] == 2 else self.end_token)
            oprot.writeFieldEnd()
        if self.keys_per_split is not None:
            oprot.writeFieldBegin('keys_per_split', TType.I32, 4)
            oprot.writeI32(self.keys_per_split)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        if self.cfName is None:
            raise TProtocolException(message='Required field cfName is unset!')
        if self.start_token is None:
            raise TProtocolException(message='Required field start_token is unset!')
        if self.end_token is None:
            raise TProtocolException(message='Required field end_token is unset!')
        if self.keys_per_split is None:
            raise TProtocolException(message='Required field keys_per_split is unset!')
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 describe_splits_result(object):
    """
    Attributes:
     - success
     - ire
    """

    thrift_spec = (
        (0, TType.LIST, 'success', (TType.STRING, 'UTF8', False), None, ),  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
    )

    def __init__(self, success=None, ire=None,):
        self.success = success
        self.ire = ire

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.LIST:
                    self.success = []
                    (_etype385, _size382) = iprot.readListBegin()
                    for _i386 in range(_size382):
                        _elem387 = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                        self.success.append(_elem387)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('describe_splits_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.LIST, 0)
            oprot.writeListBegin(TType.STRING, len(self.success))
            for iter388 in self.success:
                oprot.writeString(iter388.encode('utf-8') if sys.version_info[0] == 2 else iter388)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 trace_next_query_args(object):

    thrift_spec = (
    )

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('trace_next_query_args')
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 trace_next_query_result(object):
    """
    Attributes:
     - success
    """

    thrift_spec = (
        (0, TType.STRING, 'success', 'BINARY', None, ),  # 0
    )

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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRING:
                    self.success = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('trace_next_query_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.STRING, 0)
            oprot.writeBinary(self.success)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 describe_splits_ex_args(object):
    """
    Attributes:
     - cfName
     - start_token
     - end_token
     - keys_per_split
    """

    thrift_spec = (
        None,  # 0
        (1, TType.STRING, 'cfName', 'UTF8', None, ),  # 1
        (2, TType.STRING, 'start_token', 'UTF8', None, ),  # 2
        (3, TType.STRING, 'end_token', 'UTF8', None, ),  # 3
        (4, TType.I32, 'keys_per_split', None, None, ),  # 4
    )

    def __init__(self, cfName=None, start_token=None, end_token=None, keys_per_split=None,):
        self.cfName = cfName
        self.start_token = start_token
        self.end_token = end_token
        self.keys_per_split = keys_per_split

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.cfName = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRING:
                    self.start_token = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRING:
                    self.end_token = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.I32:
                    self.keys_per_split = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('describe_splits_ex_args')
        if self.cfName is not None:
            oprot.writeFieldBegin('cfName', TType.STRING, 1)
            oprot.writeString(self.cfName.encode('utf-8') if sys.version_info[0] == 2 else self.cfName)
            oprot.writeFieldEnd()
        if self.start_token is not None:
            oprot.writeFieldBegin('start_token', TType.STRING, 2)
            oprot.writeString(self.start_token.encode('utf-8') if sys.version_info[0] == 2 else self.start_token)
            oprot.writeFieldEnd()
        if self.end_token is not None:
            oprot.writeFieldBegin('end_token', TType.STRING, 3)
            oprot.writeString(self.end_token.encode('utf-8') if sys.version_info[0] == 2 else self.end_token)
            oprot.writeFieldEnd()
        if self.keys_per_split is not None:
            oprot.writeFieldBegin('keys_per_split', TType.I32, 4)
            oprot.writeI32(self.keys_per_split)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        if self.cfName is None:
            raise TProtocolException(message='Required field cfName is unset!')
        if self.start_token is None:
            raise TProtocolException(message='Required field start_token is unset!')
        if self.end_token is None:
            raise TProtocolException(message='Required field end_token is unset!')
        if self.keys_per_split is None:
            raise TProtocolException(message='Required field keys_per_split is unset!')
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 describe_splits_ex_result(object):
    """
    Attributes:
     - success
     - ire
    """

    thrift_spec = (
        (0, TType.LIST, 'success', (TType.STRUCT, (CfSplit, CfSplit.thrift_spec), False), None, ),  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
    )

    def __init__(self, success=None, ire=None,):
        self.success = success
        self.ire = ire

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.LIST:
                    self.success = []
                    (_etype392, _size389) = iprot.readListBegin()
                    for _i393 in range(_size389):
                        _elem394 = CfSplit()
                        _elem394.read(iprot)
                        self.success.append(_elem394)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('describe_splits_ex_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.LIST, 0)
            oprot.writeListBegin(TType.STRUCT, len(self.success))
            for iter395 in self.success:
                iter395.write(oprot)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 system_add_column_family_args(object):
    """
    Attributes:
     - cf_def
    """

    thrift_spec = (
        None,  # 0
        (1, TType.STRUCT, 'cf_def', (CfDef, CfDef.thrift_spec), None, ),  # 1
    )

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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.cf_def = CfDef()
                    self.cf_def.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('system_add_column_family_args')
        if self.cf_def is not None:
            oprot.writeFieldBegin('cf_def', TType.STRUCT, 1)
            self.cf_def.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

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

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 system_add_column_family_result(object):
    """
    Attributes:
     - success
     - ire
     - sde
    """

    thrift_spec = (
        (0, TType.STRING, 'success', 'UTF8', None, ),  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
        (2, TType.STRUCT, 'sde', (SchemaDisagreementException, SchemaDisagreementException.thrift_spec), None, ),  # 2
    )

    def __init__(self, success=None, ire=None, sde=None,):
        self.success = success
        self.ire = ire
        self.sde = sde

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRING:
                    self.success = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.sde = SchemaDisagreementException()
                    self.sde.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('system_add_column_family_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.STRING, 0)
            oprot.writeString(self.success.encode('utf-8') if sys.version_info[0] == 2 else self.success)
            oprot.writeFieldEnd()
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        if self.sde is not None:
            oprot.writeFieldBegin('sde', TType.STRUCT, 2)
            self.sde.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 system_drop_column_family_args(object):
    """
    Attributes:
     - column_family
    """

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

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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.column_family = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('system_drop_column_family_args')
        if self.column_family is not None:
            oprot.writeFieldBegin('column_family', TType.STRING, 1)
            oprot.writeString(self.column_family.encode('utf-8') if sys.version_info[0] == 2 else self.column_family)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

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

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 system_drop_column_family_result(object):
    """
    Attributes:
     - success
     - ire
     - sde
    """

    thrift_spec = (
        (0, TType.STRING, 'success', 'UTF8', None, ),  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
        (2, TType.STRUCT, 'sde', (SchemaDisagreementException, SchemaDisagreementException.thrift_spec), None, ),  # 2
    )

    def __init__(self, success=None, ire=None, sde=None,):
        self.success = success
        self.ire = ire
        self.sde = sde

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRING:
                    self.success = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.sde = SchemaDisagreementException()
                    self.sde.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('system_drop_column_family_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.STRING, 0)
            oprot.writeString(self.success.encode('utf-8') if sys.version_info[0] == 2 else self.success)
            oprot.writeFieldEnd()
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        if self.sde is not None:
            oprot.writeFieldBegin('sde', TType.STRUCT, 2)
            self.sde.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 system_add_keyspace_args(object):
    """
    Attributes:
     - ks_def
    """

    thrift_spec = (
        None,  # 0
        (1, TType.STRUCT, 'ks_def', (KsDef, KsDef.thrift_spec), None, ),  # 1
    )

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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.ks_def = KsDef()
                    self.ks_def.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('system_add_keyspace_args')
        if self.ks_def is not None:
            oprot.writeFieldBegin('ks_def', TType.STRUCT, 1)
            self.ks_def.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

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

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 system_add_keyspace_result(object):
    """
    Attributes:
     - success
     - ire
     - sde
    """

    thrift_spec = (
        (0, TType.STRING, 'success', 'UTF8', None, ),  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
        (2, TType.STRUCT, 'sde', (SchemaDisagreementException, SchemaDisagreementException.thrift_spec), None, ),  # 2
    )

    def __init__(self, success=None, ire=None, sde=None,):
        self.success = success
        self.ire = ire
        self.sde = sde

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRING:
                    self.success = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.sde = SchemaDisagreementException()
                    self.sde.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('system_add_keyspace_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.STRING, 0)
            oprot.writeString(self.success.encode('utf-8') if sys.version_info[0] == 2 else self.success)
            oprot.writeFieldEnd()
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        if self.sde is not None:
            oprot.writeFieldBegin('sde', TType.STRUCT, 2)
            self.sde.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 system_drop_keyspace_args(object):
    """
    Attributes:
     - keyspace
    """

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

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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.keyspace = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('system_drop_keyspace_args')
        if self.keyspace is not None:
            oprot.writeFieldBegin('keyspace', TType.STRING, 1)
            oprot.writeString(self.keyspace.encode('utf-8') if sys.version_info[0] == 2 else self.keyspace)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

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

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 system_drop_keyspace_result(object):
    """
    Attributes:
     - success
     - ire
     - sde
    """

    thrift_spec = (
        (0, TType.STRING, 'success', 'UTF8', None, ),  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
        (2, TType.STRUCT, 'sde', (SchemaDisagreementException, SchemaDisagreementException.thrift_spec), None, ),  # 2
    )

    def __init__(self, success=None, ire=None, sde=None,):
        self.success = success
        self.ire = ire
        self.sde = sde

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRING:
                    self.success = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.sde = SchemaDisagreementException()
                    self.sde.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('system_drop_keyspace_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.STRING, 0)
            oprot.writeString(self.success.encode('utf-8') if sys.version_info[0] == 2 else self.success)
            oprot.writeFieldEnd()
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        if self.sde is not None:
            oprot.writeFieldBegin('sde', TType.STRUCT, 2)
            self.sde.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 system_update_keyspace_args(object):
    """
    Attributes:
     - ks_def
    """

    thrift_spec = (
        None,  # 0
        (1, TType.STRUCT, 'ks_def', (KsDef, KsDef.thrift_spec), None, ),  # 1
    )

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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.ks_def = KsDef()
                    self.ks_def.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('system_update_keyspace_args')
        if self.ks_def is not None:
            oprot.writeFieldBegin('ks_def', TType.STRUCT, 1)
            self.ks_def.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

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

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 system_update_keyspace_result(object):
    """
    Attributes:
     - success
     - ire
     - sde
    """

    thrift_spec = (
        (0, TType.STRING, 'success', 'UTF8', None, ),  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
        (2, TType.STRUCT, 'sde', (SchemaDisagreementException, SchemaDisagreementException.thrift_spec), None, ),  # 2
    )

    def __init__(self, success=None, ire=None, sde=None,):
        self.success = success
        self.ire = ire
        self.sde = sde

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRING:
                    self.success = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.sde = SchemaDisagreementException()
                    self.sde.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('system_update_keyspace_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.STRING, 0)
            oprot.writeString(self.success.encode('utf-8') if sys.version_info[0] == 2 else self.success)
            oprot.writeFieldEnd()
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        if self.sde is not None:
            oprot.writeFieldBegin('sde', TType.STRUCT, 2)
            self.sde.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 system_update_column_family_args(object):
    """
    Attributes:
     - cf_def
    """

    thrift_spec = (
        None,  # 0
        (1, TType.STRUCT, 'cf_def', (CfDef, CfDef.thrift_spec), None, ),  # 1
    )

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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.cf_def = CfDef()
                    self.cf_def.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('system_update_column_family_args')
        if self.cf_def is not None:
            oprot.writeFieldBegin('cf_def', TType.STRUCT, 1)
            self.cf_def.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

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

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 system_update_column_family_result(object):
    """
    Attributes:
     - success
     - ire
     - sde
    """

    thrift_spec = (
        (0, TType.STRING, 'success', 'UTF8', None, ),  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
        (2, TType.STRUCT, 'sde', (SchemaDisagreementException, SchemaDisagreementException.thrift_spec), None, ),  # 2
    )

    def __init__(self, success=None, ire=None, sde=None,):
        self.success = success
        self.ire = ire
        self.sde = sde

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRING:
                    self.success = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.sde = SchemaDisagreementException()
                    self.sde.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('system_update_column_family_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.STRING, 0)
            oprot.writeString(self.success.encode('utf-8') if sys.version_info[0] == 2 else self.success)
            oprot.writeFieldEnd()
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        if self.sde is not None:
            oprot.writeFieldBegin('sde', TType.STRUCT, 2)
            self.sde.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 execute_cql_query_args(object):
    """
    Attributes:
     - query
     - compression
    """

    thrift_spec = (
        None,  # 0
        (1, TType.STRING, 'query', 'BINARY', None, ),  # 1
        (2, TType.I32, 'compression', None, None, ),  # 2
    )

    def __init__(self, query=None, compression=None,):
        self.query = query
        self.compression = compression

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.query = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.I32:
                    self.compression = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('execute_cql_query_args')
        if self.query is not None:
            oprot.writeFieldBegin('query', TType.STRING, 1)
            oprot.writeBinary(self.query)
            oprot.writeFieldEnd()
        if self.compression is not None:
            oprot.writeFieldBegin('compression', TType.I32, 2)
            oprot.writeI32(self.compression)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

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

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 execute_cql_query_result(object):
    """
    Attributes:
     - success
     - ire
     - ue
     - te
     - sde
    """

    thrift_spec = (
        (0, TType.STRUCT, 'success', (CqlResult, CqlResult.thrift_spec), None, ),  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
        (2, TType.STRUCT, 'ue', (UnavailableException, UnavailableException.thrift_spec), None, ),  # 2
        (3, TType.STRUCT, 'te', (TimedOutException, TimedOutException.thrift_spec), None, ),  # 3
        (4, TType.STRUCT, 'sde', (SchemaDisagreementException, SchemaDisagreementException.thrift_spec), None, ),  # 4
    )

    def __init__(self, success=None, ire=None, ue=None, te=None, sde=None,):
        self.success = success
        self.ire = ire
        self.ue = ue
        self.te = te
        self.sde = sde

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = CqlResult()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ue = UnavailableException()
                    self.ue.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.te = TimedOutException()
                    self.te.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.STRUCT:
                    self.sde = SchemaDisagreementException()
                    self.sde.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('execute_cql_query_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        if self.ue is not None:
            oprot.writeFieldBegin('ue', TType.STRUCT, 2)
            self.ue.write(oprot)
            oprot.writeFieldEnd()
        if self.te is not None:
            oprot.writeFieldBegin('te', TType.STRUCT, 3)
            self.te.write(oprot)
            oprot.writeFieldEnd()
        if self.sde is not None:
            oprot.writeFieldBegin('sde', TType.STRUCT, 4)
            self.sde.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 execute_cql3_query_args(object):
    """
    Attributes:
     - query
     - compression
     - consistency
    """

    thrift_spec = (
        None,  # 0
        (1, TType.STRING, 'query', 'BINARY', None, ),  # 1
        (2, TType.I32, 'compression', None, None, ),  # 2
        (3, TType.I32, 'consistency', None, None, ),  # 3
    )

    def __init__(self, query=None, compression=None, consistency=None,):
        self.query = query
        self.compression = compression
        self.consistency = consistency

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.query = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.I32:
                    self.compression = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.I32:
                    self.consistency = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('execute_cql3_query_args')
        if self.query is not None:
            oprot.writeFieldBegin('query', TType.STRING, 1)
            oprot.writeBinary(self.query)
            oprot.writeFieldEnd()
        if self.compression is not None:
            oprot.writeFieldBegin('compression', TType.I32, 2)
            oprot.writeI32(self.compression)
            oprot.writeFieldEnd()
        if self.consistency is not None:
            oprot.writeFieldBegin('consistency', TType.I32, 3)
            oprot.writeI32(self.consistency)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

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

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 execute_cql3_query_result(object):
    """
    Attributes:
     - success
     - ire
     - ue
     - te
     - sde
    """

    thrift_spec = (
        (0, TType.STRUCT, 'success', (CqlResult, CqlResult.thrift_spec), None, ),  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
        (2, TType.STRUCT, 'ue', (UnavailableException, UnavailableException.thrift_spec), None, ),  # 2
        (3, TType.STRUCT, 'te', (TimedOutException, TimedOutException.thrift_spec), None, ),  # 3
        (4, TType.STRUCT, 'sde', (SchemaDisagreementException, SchemaDisagreementException.thrift_spec), None, ),  # 4
    )

    def __init__(self, success=None, ire=None, ue=None, te=None, sde=None,):
        self.success = success
        self.ire = ire
        self.ue = ue
        self.te = te
        self.sde = sde

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = CqlResult()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ue = UnavailableException()
                    self.ue.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.te = TimedOutException()
                    self.te.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.STRUCT:
                    self.sde = SchemaDisagreementException()
                    self.sde.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('execute_cql3_query_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        if self.ue is not None:
            oprot.writeFieldBegin('ue', TType.STRUCT, 2)
            self.ue.write(oprot)
            oprot.writeFieldEnd()
        if self.te is not None:
            oprot.writeFieldBegin('te', TType.STRUCT, 3)
            self.te.write(oprot)
            oprot.writeFieldEnd()
        if self.sde is not None:
            oprot.writeFieldBegin('sde', TType.STRUCT, 4)
            self.sde.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 prepare_cql_query_args(object):
    """
    Attributes:
     - query
     - compression
    """

    thrift_spec = (
        None,  # 0
        (1, TType.STRING, 'query', 'BINARY', None, ),  # 1
        (2, TType.I32, 'compression', None, None, ),  # 2
    )

    def __init__(self, query=None, compression=None,):
        self.query = query
        self.compression = compression

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.query = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.I32:
                    self.compression = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('prepare_cql_query_args')
        if self.query is not None:
            oprot.writeFieldBegin('query', TType.STRING, 1)
            oprot.writeBinary(self.query)
            oprot.writeFieldEnd()
        if self.compression is not None:
            oprot.writeFieldBegin('compression', TType.I32, 2)
            oprot.writeI32(self.compression)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

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

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 prepare_cql_query_result(object):
    """
    Attributes:
     - success
     - ire
    """

    thrift_spec = (
        (0, TType.STRUCT, 'success', (CqlPreparedResult, CqlPreparedResult.thrift_spec), None, ),  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
    )

    def __init__(self, success=None, ire=None,):
        self.success = success
        self.ire = ire

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = CqlPreparedResult()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('prepare_cql_query_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 prepare_cql3_query_args(object):
    """
    Attributes:
     - query
     - compression
    """

    thrift_spec = (
        None,  # 0
        (1, TType.STRING, 'query', 'BINARY', None, ),  # 1
        (2, TType.I32, 'compression', None, None, ),  # 2
    )

    def __init__(self, query=None, compression=None,):
        self.query = query
        self.compression = compression

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.query = iprot.readBinary()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.I32:
                    self.compression = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('prepare_cql3_query_args')
        if self.query is not None:
            oprot.writeFieldBegin('query', TType.STRING, 1)
            oprot.writeBinary(self.query)
            oprot.writeFieldEnd()
        if self.compression is not None:
            oprot.writeFieldBegin('compression', TType.I32, 2)
            oprot.writeI32(self.compression)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

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

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 prepare_cql3_query_result(object):
    """
    Attributes:
     - success
     - ire
    """

    thrift_spec = (
        (0, TType.STRUCT, 'success', (CqlPreparedResult, CqlPreparedResult.thrift_spec), None, ),  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
    )

    def __init__(self, success=None, ire=None,):
        self.success = success
        self.ire = ire

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = CqlPreparedResult()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('prepare_cql3_query_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 execute_prepared_cql_query_args(object):
    """
    Attributes:
     - itemId
     - values
    """

    thrift_spec = (
        None,  # 0
        (1, TType.I32, 'itemId', None, None, ),  # 1
        (2, TType.LIST, 'values', (TType.STRING, 'BINARY', False), None, ),  # 2
    )

    def __init__(self, itemId=None, values=None,):
        self.itemId = itemId
        self.values = values

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.I32:
                    self.itemId = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.LIST:
                    self.values = []
                    (_etype399, _size396) = iprot.readListBegin()
                    for _i400 in range(_size396):
                        _elem401 = iprot.readBinary()
                        self.values.append(_elem401)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('execute_prepared_cql_query_args')
        if self.itemId is not None:
            oprot.writeFieldBegin('itemId', TType.I32, 1)
            oprot.writeI32(self.itemId)
            oprot.writeFieldEnd()
        if self.values is not None:
            oprot.writeFieldBegin('values', TType.LIST, 2)
            oprot.writeListBegin(TType.STRING, len(self.values))
            for iter402 in self.values:
                oprot.writeBinary(iter402)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

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

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 execute_prepared_cql_query_result(object):
    """
    Attributes:
     - success
     - ire
     - ue
     - te
     - sde
    """

    thrift_spec = (
        (0, TType.STRUCT, 'success', (CqlResult, CqlResult.thrift_spec), None, ),  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
        (2, TType.STRUCT, 'ue', (UnavailableException, UnavailableException.thrift_spec), None, ),  # 2
        (3, TType.STRUCT, 'te', (TimedOutException, TimedOutException.thrift_spec), None, ),  # 3
        (4, TType.STRUCT, 'sde', (SchemaDisagreementException, SchemaDisagreementException.thrift_spec), None, ),  # 4
    )

    def __init__(self, success=None, ire=None, ue=None, te=None, sde=None,):
        self.success = success
        self.ire = ire
        self.ue = ue
        self.te = te
        self.sde = sde

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = CqlResult()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ue = UnavailableException()
                    self.ue.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.te = TimedOutException()
                    self.te.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.STRUCT:
                    self.sde = SchemaDisagreementException()
                    self.sde.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('execute_prepared_cql_query_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        if self.ue is not None:
            oprot.writeFieldBegin('ue', TType.STRUCT, 2)
            self.ue.write(oprot)
            oprot.writeFieldEnd()
        if self.te is not None:
            oprot.writeFieldBegin('te', TType.STRUCT, 3)
            self.te.write(oprot)
            oprot.writeFieldEnd()
        if self.sde is not None:
            oprot.writeFieldBegin('sde', TType.STRUCT, 4)
            self.sde.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 execute_prepared_cql3_query_args(object):
    """
    Attributes:
     - itemId
     - values
     - consistency
    """

    thrift_spec = (
        None,  # 0
        (1, TType.I32, 'itemId', None, None, ),  # 1
        (2, TType.LIST, 'values', (TType.STRING, 'BINARY', False), None, ),  # 2
        (3, TType.I32, 'consistency', None, None, ),  # 3
    )

    def __init__(self, itemId=None, values=None, consistency=None,):
        self.itemId = itemId
        self.values = values
        self.consistency = consistency

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.I32:
                    self.itemId = iprot.readI32()
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.LIST:
                    self.values = []
                    (_etype406, _size403) = iprot.readListBegin()
                    for _i407 in range(_size403):
                        _elem408 = iprot.readBinary()
                        self.values.append(_elem408)
                    iprot.readListEnd()
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.I32:
                    self.consistency = iprot.readI32()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('execute_prepared_cql3_query_args')
        if self.itemId is not None:
            oprot.writeFieldBegin('itemId', TType.I32, 1)
            oprot.writeI32(self.itemId)
            oprot.writeFieldEnd()
        if self.values is not None:
            oprot.writeFieldBegin('values', TType.LIST, 2)
            oprot.writeListBegin(TType.STRING, len(self.values))
            for iter409 in self.values:
                oprot.writeBinary(iter409)
            oprot.writeListEnd()
            oprot.writeFieldEnd()
        if self.consistency is not None:
            oprot.writeFieldBegin('consistency', TType.I32, 3)
            oprot.writeI32(self.consistency)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

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

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 execute_prepared_cql3_query_result(object):
    """
    Attributes:
     - success
     - ire
     - ue
     - te
     - sde
    """

    thrift_spec = (
        (0, TType.STRUCT, 'success', (CqlResult, CqlResult.thrift_spec), None, ),  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
        (2, TType.STRUCT, 'ue', (UnavailableException, UnavailableException.thrift_spec), None, ),  # 2
        (3, TType.STRUCT, 'te', (TimedOutException, TimedOutException.thrift_spec), None, ),  # 3
        (4, TType.STRUCT, 'sde', (SchemaDisagreementException, SchemaDisagreementException.thrift_spec), None, ),  # 4
    )

    def __init__(self, success=None, ire=None, ue=None, te=None, sde=None,):
        self.success = success
        self.ire = ire
        self.ue = ue
        self.te = te
        self.sde = sde

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec))
            return
        iprot.readStructBegin()
        while True:
            (fname, ftype, fid) = iprot.readFieldBegin()
            if ftype == TType.STOP:
                break
            if fid == 0:
                if ftype == TType.STRUCT:
                    self.success = CqlResult()
                    self.success.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 1:
                if ftype == TType.STRUCT:
                    self.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 2:
                if ftype == TType.STRUCT:
                    self.ue = UnavailableException()
                    self.ue.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 3:
                if ftype == TType.STRUCT:
                    self.te = TimedOutException()
                    self.te.read(iprot)
                else:
                    iprot.skip(ftype)
            elif fid == 4:
                if ftype == TType.STRUCT:
                    self.sde = SchemaDisagreementException()
                    self.sde.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('execute_prepared_cql3_query_result')
        if self.success is not None:
            oprot.writeFieldBegin('success', TType.STRUCT, 0)
            self.success.write(oprot)
            oprot.writeFieldEnd()
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        if self.ue is not None:
            oprot.writeFieldBegin('ue', TType.STRUCT, 2)
            self.ue.write(oprot)
            oprot.writeFieldEnd()
        if self.te is not None:
            oprot.writeFieldBegin('te', TType.STRUCT, 3)
            self.te.write(oprot)
            oprot.writeFieldEnd()
        if self.sde is not None:
            oprot.writeFieldBegin('sde', TType.STRUCT, 4)
            self.sde.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 set_cql_version_args(object):
    """
    Attributes:
     - version
    """

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

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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.version = iprot.readString().decode('utf-8') if sys.version_info[0] == 2 else iprot.readString()
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('set_cql_version_args')
        if self.version is not None:
            oprot.writeFieldBegin('version', TType.STRING, 1)
            oprot.writeString(self.version.encode('utf-8') if sys.version_info[0] == 2 else self.version)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

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

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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 set_cql_version_result(object):
    """
    Attributes:
     - ire
    """

    thrift_spec = (
        None,  # 0
        (1, TType.STRUCT, 'ire', (InvalidRequestException, InvalidRequestException.thrift_spec), None, ),  # 1
    )

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

    def read(self, iprot):
        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
            iprot._fast_decode(self, iprot, (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.ire = InvalidRequestException()
                    self.ire.read(iprot)
                else:
                    iprot.skip(ftype)
            else:
                iprot.skip(ftype)
            iprot.readFieldEnd()
        iprot.readStructEnd()

    def write(self, oprot):
        if oprot._fast_encode is not None and self.thrift_spec is not None:
            oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec)))
            return
        oprot.writeStructBegin('set_cql_version_result')
        if self.ire is not None:
            oprot.writeFieldBegin('ire', TType.STRUCT, 1)
            self.ire.write(oprot)
            oprot.writeFieldEnd()
        oprot.writeFieldStop()
        oprot.writeStructEnd()

    def validate(self):
        return

    def __repr__(self):
        L = ['%s=%r' % (key, value)
             for key, value in self.__dict__.items()]
        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)