def to_pb(self):
"""Converts the :class:`TimestampRange` to a protobuf.
:rtype: :class:`.data_pb2.TimestampRange`
:returns: The converted current object.
"""
timestamp_range_kwargs = {}
if self.start is not None:
timestamp_range_kwargs['start_timestamp_micros'] = (
_timestamp_to_microseconds(self.start))
if self.end is not None:
timestamp_range_kwargs['end_timestamp_micros'] = (
_timestamp_to_microseconds(self.end))
return data_pb2.TimestampRange(**timestamp_range_kwargs)
def _write_to_row(self, row1=None, row2=None, row3=None, row4=None):
timestamp1 = datetime.datetime.utcnow().replace(tzinfo=pytz.utc)
# Must be millisecond granularity.
timestamp1 = _microseconds_to_timestamp(
_timestamp_to_microseconds(timestamp1))
# 1000 microseconds is a millisecond
timestamp2 = timestamp1 + datetime.timedelta(microseconds=1000)
timestamp3 = timestamp1 + datetime.timedelta(microseconds=2000)
timestamp4 = timestamp1 + datetime.timedelta(microseconds=3000)
if row1 is not None:
row1.set_cell(COLUMN_FAMILY_ID1, COL_NAME1, CELL_VAL1,
timestamp=timestamp1)
if row2 is not None:
row2.set_cell(COLUMN_FAMILY_ID1, COL_NAME1, CELL_VAL2,
timestamp=timestamp2)
if row3 is not None:
row3.set_cell(COLUMN_FAMILY_ID1, COL_NAME2, CELL_VAL3,
timestamp=timestamp3)
if row4 is not None:
row4.set_cell(COLUMN_FAMILY_ID2, COL_NAME3, CELL_VAL4,
timestamp=timestamp4)
# Create the cells we will check.
cell1 = Cell(CELL_VAL1, timestamp1)
cell2 = Cell(CELL_VAL2, timestamp2)
cell3 = Cell(CELL_VAL3, timestamp3)
cell4 = Cell(CELL_VAL4, timestamp4)
return cell1, cell2, cell3, cell4
def set_cell(self, column_family_id, column, value, timestamp=None,
state=None):
"""Sets a value in this row.
The cell is determined by the ``row_key`` of the :class:`Row` and the
``column``. The ``column`` must be in an existing
:class:`.column_family.ColumnFamily` (as determined by
``column_family_id``).
.. note::
This method adds a mutation to the accumulated mutations on this
:class:`Row`, but does not make an API request. To actually
send an API request (with the mutations) to the Google Cloud
Bigtable API, call :meth:`commit`.
:type column_family_id: str
:param column_family_id: The column family that contains the column.
Must be of the form
``[_a-zA-Z0-9][-_.a-zA-Z0-9]*``.
:type column: bytes
:param column: The column within the column family where the cell
is located.
:type value: bytes or :class:`int`
:param value: The value to set in the cell. If an integer is used,
will be interpreted as a 64-bit big-endian signed
integer (8 bytes).
:type timestamp: :class:`datetime.datetime`
:param timestamp: (Optional) The timestamp of the operation.
:type state: bool
:param state: (Optional) The state that the mutation should be
applied in. Unset if the mutation is not conditional,
otherwise :data:`True` or :data:`False`.
"""
column = _to_bytes(column)
if isinstance(value, six.integer_types):
value = _PACK_I64(value)
value = _to_bytes(value)
if timestamp is None:
# Use -1 for current Bigtable server time.
timestamp_micros = -1
else:
timestamp_micros = _timestamp_to_microseconds(timestamp)
mutation_val = data_pb2.Mutation.SetCell(
family_name=column_family_id,
column_qualifier=column,
timestamp_micros=timestamp_micros,
value=value,
)
mutation_pb = data_pb2.Mutation(set_cell=mutation_val)
self._get_mutations(state).append(mutation_pb)
def _cells_to_pairs(cells, include_timestamp=False):
"""Converts list of cells to HappyBase format.
:type cells: list
:param cells: List of :class:`.Cell` returned from a read request.
:type include_timestamp: bool
:param include_timestamp: Flag to indicate if cell timestamps should be
included with the output.
:rtype: list
:returns: List of values in the cell. If ``include_timestamp=True``, each
value will be a pair, with the first part the bytes value in
the cell and the second part the number of milliseconds in the
timestamp on the cell.
"""
result = []
for cell in cells:
if include_timestamp:
ts_millis = _timestamp_to_microseconds(cell.timestamp) // 1000
result.append((cell.value, ts_millis))
else:
result.append(cell.value)
return result
def _callFUT(self, timestamp, granularity=1000):
from gcloud_bigtable._helpers import _timestamp_to_microseconds
return _timestamp_to_microseconds(timestamp, granularity=granularity)
