try:

return _clean_name_cache[name]

except KeyError:

clean = NON_ALPHA_REGEX.sub("_", START_BADCHAR_REGEX.sub("", END_BADCHAR_REGEX.sub("", name)))

_clean_name_cache[name] = clean

"""

"""

def __init__(self, ordered_dict):

self._dict = ordered_dict

self._tuple = tuple(ordered_dict.values())

def __getattr__(self, name):

return self._dict[name]

def __getitem__(self, idx):

return self._tuple[idx]

def __iter__(self):

return iter(self._tuple)

def __repr__(self):

return '{t}({od})'.format(t=self.__class__.__name__,

"""

return [PseudoNamedTupleRow(od)

"""

clean_column_names = map(_clean_column_name, colnames)

try:

Row = namedtuple('Row', clean_column_names)

except SyntaxError:

warnings.warn(

"Failed creating namedtuple for a result because there were too "

"many columns. This is due to a Python limitation that affects "

"namedtuple in Python 3.0-3.6 (see issue18896). The row will be "

"created with {substitute_factory_name}, which lacks some namedtuple "

"features and is slower. To avoid slower performance accessing "

"values on row objects, Upgrade to Python 3.7, or use a different "

"row factory. (column names: {colnames})".format(

substitute_factory_name=pseudo_namedtuple_factory.__name__,

colnames=colnames

)

)

return pseudo_namedtuple_factory(colnames, rows)

except Exception:

clean_column_names = list(map(_clean_column_name, colnames)) # create list because py3 map object will be consumed by first attempt

log.warning("Failed creating named tuple for results with column names %s (cleaned: %s) "

"(see Python 'namedtuple' documentation for details on name rules). "

"Results will be returned with positional names. "

"Avoid this by choosing different names, using SELECT \"<col name>\" AS aliases, "

"or specifying a different row_factory on your Session" %

(colnames, clean_column_names))

Row = namedtuple('Row', _sanitize_identifiers(clean_column_names))

"""

"""

"""

retry_policy = None

"""

consistency_level = None

"""

fetch_size = FETCH_SIZE_UNSET

"""

keyspace = None

"""

custom_payload = None

"""

is_idempotent = False

"""

_serial_consistency_level = None

_routing_key = None

def __init__(self, retry_policy=None, consistency_level=None, routing_key=None,

serial_consistency_level=None, fetch_size=FETCH_SIZE_UNSET, keyspace=None, custom_payload=None,

is_idempotent=False):

if retry_policy and not hasattr(retry_policy, 'on_read_timeout'): # just checking one method to detect positional parameter errors

raise ValueError('retry_policy should implement cassandra.policies.RetryPolicy')

if retry_policy is not None:

self.retry_policy = retry_policy

if consistency_level is not None:

self.consistency_level = consistency_level

self._routing_key = routing_key

if serial_consistency_level is not None:

self.serial_consistency_level = serial_consistency_level

if fetch_size is not FETCH_SIZE_UNSET:

self.fetch_size = fetch_size

if keyspace is not None:

self.keyspace = keyspace

if custom_payload is not None:

self.custom_payload = custom_payload

self.is_idempotent = is_idempotent

def _key_parts_packed(self, parts):

for p in parts:

l = len(p)

yield struct.pack(">H%dsB" % l, l, p, 0)

def _get_routing_key(self):

return self._routing_key

def _set_routing_key(self, key):

if isinstance(key, (list, tuple)):

if len(key) == 1:

self._routing_key = key[0]

else:

self._routing_key = b"".join(self._key_parts_packed(key))

else:

self._routing_key = key

def _del_routing_key(self):

self._routing_key = None

routing_key = property(

_get_routing_key,

_set_routing_key,

_del_routing_key,

"""

""")

def _get_serial_consistency_level(self):

return self._serial_consistency_level

def _set_serial_consistency_level(self, serial_consistency_level):

if (serial_consistency_level is not None and

not ConsistencyLevel.is_serial(serial_consistency_level)):

raise ValueError(

"serial_consistency_level must be either ConsistencyLevel.SERIAL "

"or ConsistencyLevel.LOCAL_SERIAL")

self._serial_consistency_level = serial_consistency_level

def _del_serial_consistency_level(self):

self._serial_consistency_level = None

serial_consistency_level = property(

_get_serial_consistency_level,

_set_serial_consistency_level,

_del_serial_consistency_level,

"""

"""

def __init__(self, query_string, retry_policy=None, consistency_level=None, routing_key=None,

serial_consistency_level=None, fetch_size=FETCH_SIZE_UNSET, keyspace=None,

custom_payload=None, is_idempotent=False):

"""

Statement.__init__(self, retry_policy, consistency_level, routing_key,

serial_consistency_level, fetch_size, keyspace, custom_payload, is_idempotent)

self._query_string = query_string

@property

def query_string(self):

return self._query_string

def __str__(self):

consistency = ConsistencyLevel.value_to_name.get(self.consistency_level, 'Not Set')

return (u'<SimpleStatement query="%s", consistency=%s>' %

(self.query_string, consistency))

"""

column_metadata = None #TODO: make this bind_metadata in next major

retry_policy = None

consistency_level = None

custom_payload = None

fetch_size = FETCH_SIZE_UNSET

keyspace = None # change to prepared_keyspace in major release

protocol_version = None

query_id = None

query_string = None

result_metadata = None

result_metadata_id = None

routing_key_indexes = None

_routing_key_index_set = None

serial_consistency_level = None # TODO never used?

def __init__(self, column_metadata, query_id, routing_key_indexes, query,

keyspace, protocol_version, result_metadata, result_metadata_id):

self.column_metadata = column_metadata

self.query_id = query_id

self.routing_key_indexes = routing_key_indexes

self.query_string = query

self.keyspace = keyspace

self.protocol_version = protocol_version

self.result_metadata = result_metadata

self.result_metadata_id = result_metadata_id

self.is_idempotent = False

@classmethod

def from_message(cls, query_id, column_metadata, pk_indexes, cluster_metadata,

query, prepared_keyspace, protocol_version, result_metadata,

result_metadata_id):

if not column_metadata:

return PreparedStatement(column_metadata, query_id, None, query, prepared_keyspace, protocol_version, result_metadata, result_metadata_id)

if pk_indexes:

routing_key_indexes = pk_indexes

else:

routing_key_indexes = None

first_col = column_metadata[0]

ks_meta = cluster_metadata.keyspaces.get(first_col.keyspace_name)

if ks_meta:

table_meta = ks_meta.tables.get(first_col.table_name)

if table_meta:

partition_key_columns = table_meta.partition_key

# make a map of {column_name: index} for each column in the statement

statement_indexes = dict((c.name, i) for i, c in enumerate(column_metadata))

# a list of which indexes in the statement correspond to partition key items

try:

routing_key_indexes = [statement_indexes[c.name]

for c in partition_key_columns]

except KeyError: # we're missing a partition key component in the prepared

pass # statement; just leave routing_key_indexes as None

return PreparedStatement(column_metadata, query_id, routing_key_indexes,

query, prepared_keyspace, protocol_version, result_metadata,

result_metadata_id)

def bind(self, values):

"""

return BoundStatement(self).bind(values)

def is_routing_key_index(self, i):

if self._routing_key_index_set is None:

self._routing_key_index_set = set(self.routing_key_indexes) if self.routing_key_indexes else set()

return i in self._routing_key_index_set

def __str__(self):

consistency = ConsistencyLevel.value_to_name.get(self.consistency_level, 'Not Set')

return (u'<PreparedStatement query="%s", consistency=%s>' %

(self.query_string, consistency))

"""

prepared_statement = None

"""

values = None

"""

def __init__(self, prepared_statement, retry_policy=None, consistency_level=None, routing_key=None,

serial_consistency_level=None, fetch_size=FETCH_SIZE_UNSET, keyspace=None,

custom_payload=None):

"""

self.prepared_statement = prepared_statement

self.retry_policy = prepared_statement.retry_policy

self.consistency_level = prepared_statement.consistency_level

self.serial_consistency_level = prepared_statement.serial_consistency_level

self.fetch_size = prepared_statement.fetch_size

self.custom_payload = prepared_statement.custom_payload

self.is_idempotent = prepared_statement.is_idempotent

self.values = []

meta = prepared_statement.column_metadata

if meta:

self.keyspace = meta[0].keyspace_name

Statement.__init__(self, retry_policy, consistency_level, routing_key,

serial_consistency_level, fetch_size, keyspace, custom_payload,

prepared_statement.is_idempotent)

def bind(self, values):

"""

if values is None:

values = ()

proto_version = self.prepared_statement.protocol_version

col_meta = self.prepared_statement.column_metadata

# special case for binding dicts

if isinstance(values, dict):

values_dict = values

values = []

# sort values accordingly

for col in col_meta:

try:

values.append(values_dict[col.name])

except KeyError:

if proto_version >= 4:

values.append(UNSET_VALUE)

else:

raise KeyError(

'Column name `%s` not found in bound dict.' %

(col.name))

value_len = len(values)

col_meta_len = len(col_meta)

if value_len > col_meta_len:

raise ValueError(

"Too many arguments provided to bind() (got %d, expected %d)" %

(len(values), len(col_meta)))

# this is fail-fast for clarity pre-v4. When v4 can be assumed,

# the error will be better reported when UNSET_VALUE is implicitly added.

if proto_version < 4 and self.prepared_statement.routing_key_indexes and \

value_len < len(self.prepared_statement.routing_key_indexes):

raise ValueError(

"Too few arguments provided to bind() (got %d, required %d for routing key)" %

(value_len, len(self.prepared_statement.routing_key_indexes)))

self.raw_values = values

self.values = []

for value, col_spec in zip(values, col_meta):

if value is None:

self.values.append(None)

elif value is UNSET_VALUE:

if proto_version >= 4:

self._append_unset_value()

else:

raise ValueError("Attempt to bind UNSET_VALUE while using unsuitable protocol version (%d < 4)" % proto_version)

else:

try:

self.values.append(col_spec.type.serialize(value, proto_version))

except (TypeError, struct.error) as exc:

actual_type = type(value)

message = ('Received an argument of invalid type for column "%s". '

'Expected: %s, Got: %s; (%s)' % (col_spec.name, col_spec.type, actual_type, exc))

raise TypeError(message)

if proto_version >= 4:

diff = col_meta_len - len(self.values)

if diff:

for _ in range(diff):

self._append_unset_value()

return self

def _append_unset_value(self):

next_index = len(self.values)

if self.prepared_statement.is_routing_key_index(next_index):

col_meta = self.prepared_statement.column_metadata[next_index]

raise ValueError("Cannot bind UNSET_VALUE as a part of the routing key '%s'" % col_meta.name)

self.values.append(UNSET_VALUE)

@property

def routing_key(self):

if not self.prepared_statement.routing_key_indexes:

return None

if self._routing_key is not None:

return self._routing_key

routing_indexes = self.prepared_statement.routing_key_indexes

if len(routing_indexes) == 1:

self._routing_key = self.values[routing_indexes[0]]

else:

self._routing_key = b"".join(self._key_parts_packed(self.values[i] for i in routing_indexes))

return self._routing_key

def __str__(self):

consistency = ConsistencyLevel.value_to_name.get(self.consistency_level, 'Not Set')

return (u'<BoundStatement query="%s", values=%s, consistency=%s>' %

(self.prepared_statement.query_string, self.raw_values, consistency))

"""

LOGGED = None

"""

UNLOGGED = None

"""

COUNTER = None

"""

def __init__(self, name, value):

self.name = name

self.value = value

def __str__(self):

return self.name

def __repr__(self):

"""

batch_type = None

"""

serial_consistency_level = None

"""

_statements_and_parameters = None

_session = None

def __init__(self, batch_type=BatchType.LOGGED, retry_policy=None,

consistency_level=None, serial_consistency_level=None,

session=None, custom_payload=None):

"""

self.batch_type = batch_type

self._statements_and_parameters = []

self._session = session

Statement.__init__(self, retry_policy=retry_policy, consistency_level=consistency_level,

serial_consistency_level=serial_consistency_level, custom_payload=custom_payload)

def clear(self):

"""

del self._statements_and_parameters[:]

self.keyspace = None

self.routing_key = None

if self.custom_payload:

self.custom_payload.clear()

def add(self, statement, parameters=None):

"""

if isinstance(statement, six.string_types):

if parameters:

encoder = Encoder() if self._session is None else self._session.encoder

statement = bind_params(statement, parameters, encoder)

self._add_statement_and_params(False, statement, ())

elif isinstance(statement, PreparedStatement):

query_id = statement.query_id

bound_statement = statement.bind(() if parameters is None else parameters)

self._update_state(bound_statement)

self._add_statement_and_params(True, query_id, bound_statement.values)

elif isinstance(statement, BoundStatement):

if parameters:

raise ValueError(

"Parameters cannot be passed with a BoundStatement "

"to BatchStatement.add()")

self._update_state(statement)

self._add_statement_and_params(True, statement.prepared_statement.query_id, statement.values)

else:

# it must be a SimpleStatement

query_string = statement.query_string

if parameters:

encoder = Encoder() if self._session is None else self._session.encoder

query_string = bind_params(query_string, parameters, encoder)

self._update_state(statement)

self._add_statement_and_params(False, query_string, ())

return self

def add_all(self, statements, parameters):

"""

for statement, value in zip(statements, parameters):

self.add(statement, value)

def _add_statement_and_params(self, is_prepared, statement, parameters):

if len(self._statements_and_parameters) >= 0xFFFF:

raise ValueError("Batch statement cannot contain more than %d statements." % 0xFFFF)

self._statements_and_parameters.append((is_prepared, statement, parameters))

def _maybe_set_routing_attributes(self, statement):

if self.routing_key is None:

if statement.keyspace and statement.routing_key:

self.routing_key = statement.routing_key

self.keyspace = statement.keyspace

def _update_custom_payload(self, statement):

if statement.custom_payload:

if self.custom_payload is None:

self.custom_payload = {}

self.custom_payload.update(statement.custom_payload)

def _update_state(self, statement):

self._maybe_set_routing_attributes(statement)

self._update_custom_payload(statement)

def __len__(self):

return len(self._statements_and_parameters)

def __str__(self):

consistency = ConsistencyLevel.value_to_name.get(self.consistency_level, 'Not Set')

return (u'<BatchStatement type=%s, statements=%d, consistency=%s>' %

(self.batch_type, len(self), consistency))

if six.PY2 and isinstance(query, six.text_type):

query = query.encode('utf-8')

if isinstance(params, dict):

return query % dict((k, encoder.cql_encode_all_types(v)) for k, v in six.iteritems(params))

else:

"""

"""

trace_id = None

"""

request_type = None

"""

duration = None

"""

client = None

"""

coordinator = None

"""

parameters = None

"""

started_at = None

"""

events = None

"""

_session = None

_SELECT_SESSIONS_FORMAT = "SELECT * FROM system_traces.sessions WHERE session_id = %s"

_SELECT_EVENTS_FORMAT = "SELECT * FROM system_traces.events WHERE session_id = %s"

_BASE_RETRY_SLEEP = 0.003

def __init__(self, trace_id, session):

self.trace_id = trace_id

self._session = session

def populate(self, max_wait=2.0, wait_for_complete=True, query_cl=None):

"""

attempt = 0

start = time.time()

while True:

time_spent = time.time() - start

if max_wait is not None and time_spent >= max_wait:

raise TraceUnavailable(

"Trace information was not available within %f seconds. Consider raising Session.max_trace_wait." % (max_wait,))

log.debug("Attempting to fetch trace info for trace ID: %s", self.trace_id)

session_results = self._execute(

SimpleStatement(self._SELECT_SESSIONS_FORMAT, consistency_level=query_cl), (self.trace_id,), time_spent, max_wait)

# PYTHON-730: There is race condition that the duration mutation is written before started_at the for fast queries

is_complete = session_results and session_results[0].duration is not None and session_results[0].started_at is not None

if not session_results or (wait_for_complete and not is_complete):