a !f@sdZddlZddlZddlmZddlmZddlmZddlmZ ddlm Z e dj Zd ZGd d d eZGd d d eZGdddeZGdddeZGdddeZddZddZdS)z6User friendly container for Google Cloud Bigtable Row.N)_datetime_from_microseconds)_microseconds_from_datetime) _to_bytes)data_pb2) bigtable_pb2z>qic@seZdZdZddZdS)RowaBase representation of a Google Cloud Bigtable Row. This class has three subclasses corresponding to the three RPC methods for sending row mutations: * :class:`DirectRow` for ``MutateRow`` * :class:`ConditionalRow` for ``CheckAndMutateRow`` * :class:`AppendRow` for ``ReadModifyWriteRow`` :type row_key: bytes :param row_key: The key for the current row. :type table: :class:`Table ` :param table: The table that owns the row. cCst||_||_dSN)r_row_key_tableselfrow_keytablerT/var/www/html/python-backend/venv/lib/python3.9/site-packages/gcloud/bigtable/row.py__init__6s z Row.__init__N)__name__ __module__ __qualname____doc__rrrrrr%src@s<eZdZdZeZddZd ddZd ddZd d d Z dS) _SetDeleteRowaRow helper for setting or deleting cell values. Implements helper methods to add mutations to set or delete cell contents: * :meth:`set_cell` * :meth:`delete` * :meth:`delete_cell` * :meth:`delete_cells` :type row_key: bytes :param row_key: The key for the current row. :type table: :class:`Table ` :param table: The table that owns the row. cCstdS)aGets the list of mutations for a given state. This method intended to be implemented by subclasses. ``state`` may not need to be used by all subclasses. :type state: bool :param state: The state that the mutation should be applied in. :raises: :class:`NotImplementedError ` always. N)NotImplementedErrorr staterrr_get_mutationsOsz_SetDeleteRow._get_mutationsNc Cszt|}t|tjrt|}t|}|dur2d}nt|}||d8}tjj||||d}tj|d}| | |dS)aHelper for :meth:`set_cell` Adds a mutation to set the value in a specific cell. ``state`` is unused by :class:`DirectRow` but is used by subclasses. :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 is passed along to :meth:`_get_mutations`. Ni) family_namecolumn_qualifiertimestamp_microsvalue)set_cell) r isinstancesix integer_types _PACK_I64r data_v2_pb2MutationZSetCellrappend) r column_family_idcolumnr timestamprr mutation_val mutation_pbrrr _set_cell_s    z_SetDeleteRow._set_cellcCs*tj}tj|d}|||dS)a_Helper for :meth:`delete` Adds a delete mutation (for the entire row) to the accumulated mutations. ``state`` is unused by :class:`DirectRow` but is used by subclasses. :type state: bool :param state: (Optional) The state that is passed along to :meth:`_get_mutations`. )Zdelete_from_rowN)r%r&Z DeleteFromRowrr')r rr+r,rrr_deletes  z_SetDeleteRow._deletec Cs||}||jur:tjj|d}tj|d}||nni}|durR||d<g} |D]B} t| } |j|| dtjj fi|}tj|d}| |qZ| | dS)a?Helper for :meth:`delete_cell` and :meth:`delete_cells`. ``state`` is unused by :class:`DirectRow` but is used by subclasses. :type column_family_id: str :param column_family_id: The column family that contains the column or columns with cells being deleted. Must be of the form ``[_a-zA-Z0-9][-_.a-zA-Z0-9]*``. :type columns: :class:`list` of :class:`str` / :func:`unicode `, or :class:`object` :param columns: The columns within the column family that will have cells deleted. If :attr:`ALL_COLUMNS` is used then the entire column family will be deleted from the row. :type time_range: :class:`TimestampRange` :param time_range: (Optional) The range of time within which cells should be deleted. :type state: bool :param state: (Optional) The state that is passed along to :meth:`_get_mutations`. )r)Zdelete_from_familyN time_range)rr)Zdelete_from_column) r ALL_COLUMNSr%r&ZDeleteFromFamilyr'to_pbrupdateZDeleteFromColumnextend) r r(columnsr/rmutations_listr+r,Z delete_kwargsZ to_appendr)rrr _delete_cellss2       z_SetDeleteRow._delete_cells)NN)N)NN) rrrrobjectr0rr-r.r6rrrrr;s 3 rcs^eZdZdZfddZddZdddZd d Zdd d Zdd dZ ddZ ddZ Z S) DirectRowamGoogle Cloud Bigtable Row for sending "direct" mutations. These mutations directly set or delete cell contents: * :meth:`set_cell` * :meth:`delete` * :meth:`delete_cell` * :meth:`delete_cells` These methods can be used directly:: >>> row = table.row(b'row-key1') >>> row.set_cell(u'fam', b'col1', b'cell-val') >>> row.delete_cell(u'fam', b'col2') .. note:: A :class:`DirectRow` accumulates mutations locally via the :meth:`set_cell`, :meth:`delete`, :meth:`delete_cell` and :meth:`delete_cells` methods. To actually send these mutations to the Google Cloud Bigtable API, you must call :meth:`commit`. :type row_key: bytes :param row_key: The key for the current row. :type table: :class:`Table ` :param table: The table that owns the row. cstt|||g|_dSr)superr8r _pb_mutationsr  __class__rrrszDirectRow.__init__cCs|jS)agGets the list of mutations for a given state. ``state`` is unused by :class:`DirectRow` but is used by subclasses. :type state: bool :param state: The state that the mutation should be applied in. :rtype: list :returns: The list to add new mutations to (for the current state). r:rrrrrs zDirectRow._get_mutationsNcCs|j||||dddS)aSets a value in this row. The cell is determined by the ``row_key`` of this :class:`DirectRow` and the ``column``. The ``column`` must be in an existing :class:`.ColumnFamily` (as determined by ``column_family_id``). .. note:: This method adds a mutation to the accumulated mutations on this 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. Nr*rr-)r r(r)rr*rrrr s zDirectRow.set_cellcCs|jdddS)aADeletes this row from the table. .. note:: This method adds a mutation to the accumulated mutations on this 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`. Nrr.r rrrdelete0s zDirectRow.deletecCs|j||g|dddS)aDeletes cell in this row. .. note:: This method adds a mutation to the accumulated mutations on this 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 or columns with cells being deleted. Must be of the form ``[_a-zA-Z0-9][-_.a-zA-Z0-9]*``. :type column: bytes :param column: The column within the column family that will have a cell deleted. :type time_range: :class:`TimestampRange` :param time_range: (Optional) The range of time within which cells should be deleted. Nr/rr6)r r(r)r/rrr delete_cell<s zDirectRow.delete_cellcCs|j|||dddS)aWDeletes cells in this row. .. note:: This method adds a mutation to the accumulated mutations on this 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 or columns with cells being deleted. Must be of the form ``[_a-zA-Z0-9][-_.a-zA-Z0-9]*``. :type columns: :class:`list` of :class:`str` / :func:`unicode `, or :class:`object` :param columns: The columns within the column family that will have cells deleted. If :attr:`ALL_COLUMNS` is used then the entire column family will be deleted from the row. :type time_range: :class:`TimestampRange` :param time_range: (Optional) The range of time within which cells should be deleted. NrDrE)r r(r4r/rrr delete_cellsVs zDirectRow.delete_cellscCsr|d}t|}|dkrdS|tkr6td|tftj|jj|j|d}|jj j }|j ||j |dS)aXMakes a ``MutateRow`` API request. If no mutations have been created in the row, no request is made. Mutations are applied atomically and in order, meaning that earlier mutations can be masked / negated by later ones. Cells already present in the row are left unchanged unless explicitly changed by a mutation. After committing the accumulated mutations, resets the local mutations to an empty list. :raises: :class:`ValueError ` if the number of mutations exceeds the :data:`MAX_MUTATIONS`. Nrz3%d total mutations exceed the maximum allowable %d.) table_namer Z mutations)rlen MAX_MUTATIONS ValueErrormessages_v2_pb2ZMutateRowRequestr namer _instance_client _data_stubZ MutateRowtimeout_secondsclear)r r5 num_mutations request_pbclientrrrcommitrs   zDirectRow.commitcCs|jdd=dSz?Removes all currently accumulated mutations on the current row.Nr=rBrrrrRszDirectRow.clear)N)N)N) rrrrrrr rCrFrGrVrR __classcell__rrr;rr8s  "   r8cs`eZdZdZfddZddZddZdd d Zdd d ZdddZ dddZ ddZ Z S)ConditionalRowaGoogle Cloud Bigtable Row for sending mutations conditionally. Each mutation has an associated state: :data:`True` or :data:`False`. When :meth:`commit`-ed, the mutations for the :data:`True` state will be applied if the filter matches any cells in the row, otherwise the :data:`False` state will be applied. A :class:`ConditionalRow` accumulates mutations in the same way a :class:`DirectRow` does: * :meth:`set_cell` * :meth:`delete` * :meth:`delete_cell` * :meth:`delete_cells` with the only change the extra ``state`` parameter:: >>> row_cond = table.row(b'row-key2', filter_=row_filter) >>> row_cond.set_cell(u'fam', b'col', b'cell-val', state=True) >>> row_cond.delete_cell(u'fam', b'col', state=False) .. note:: As with :class:`DirectRow`, to actually send these mutations to the Google Cloud Bigtable API, you must call :meth:`commit`. :type row_key: bytes :param row_key: The key for the current row. :type table: :class:`Table ` :param table: The table that owns the row. :type filter_: :class:`.RowFilter` :param filter_: Filter to be used for conditional mutations. cs(tt|||||_g|_g|_dSr)r9rYr_filter_true_pb_mutations_false_pb_mutations)r r rfilter_r;rrrszConditionalRow.__init__cCs|r |jS|jSdS)aGets the list of mutations for a given state. Over-ridden so that the state can be used in: * :meth:`set_cell` * :meth:`delete` * :meth:`delete_cell` * :meth:`delete_cells` :type state: bool :param state: The state that the mutation should be applied in. :rtype: list :returns: The list to add new mutations to (for the current state). Nr[r\rrrrrszConditionalRow._get_mutationscCs|jdd}|jdd}t|}t|}|dkr<|dkr` if the number of mutations exceeds the :data:`MAX_MUTATIONS`. Tr@FrNzZExceed the maximum allowable mutations (%d). Had %s true mutations and %d false mutations.)rHr Zpredicate_filtertrue_mutationsfalse_mutations)rrIrJrKrLZCheckAndMutateRowRequestr rMr rZr1rNrOrPZCheckAndMutateRowrQrRZpredicate_matched)r r_r`Znum_true_mutationsZnum_false_mutationsrTrUresprrrrVs8   zConditionalRow.commitNTcCs|j|||||ddS)aSets a value in this row. The cell is determined by the ``row_key`` of this :class:`ConditionalRow` and the ``column``. The ``column`` must be in an existing :class:`.ColumnFamily` (as determined by ``column_family_id``). .. note:: This method adds a mutation to the accumulated mutations on this 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. Defaults to :data:`True`. r>Nr?)r r(r)rr*rrrrr s% zConditionalRow.set_cellcCs|j|ddS)aDeletes this row from the table. .. note:: This method adds a mutation to the accumulated mutations on this 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 state: bool :param state: (Optional) The state that the mutation should be applied in. Defaults to :data:`True`. r@NrArrrrrC2szConditionalRow.deletecCs|j||g||ddS)aDeletes cell in this row. .. note:: This method adds a mutation to the accumulated mutations on this 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 or columns with cells being deleted. Must be of the form ``[_a-zA-Z0-9][-_.a-zA-Z0-9]*``. :type column: bytes :param column: The column within the column family that will have a cell deleted. :type time_range: :class:`TimestampRange` :param time_range: (Optional) The range of time within which cells should be deleted. :type state: bool :param state: (Optional) The state that the mutation should be applied in. Defaults to :data:`True`. rDNrE)r r(r)r/rrrrrFBs zConditionalRow.delete_cellcCs|j||||ddS)aDeletes cells in this row. .. note:: This method adds a mutation to the accumulated mutations on this 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 or columns with cells being deleted. Must be of the form ``[_a-zA-Z0-9][-_.a-zA-Z0-9]*``. :type columns: :class:`list` of :class:`str` / :func:`unicode `, or :class:`object` :param columns: The columns within the column family that will have cells deleted. If :attr:`ALL_COLUMNS` is used then the entire column family will be deleted from the row. :type time_range: :class:`TimestampRange` :param time_range: (Optional) The range of time within which cells should be deleted. :type state: bool :param state: (Optional) The state that the mutation should be applied in. Defaults to :data:`True`. rDNrE)r r(r4r/rrrrrGas zConditionalRow.delete_cellscCs|jdd=|jdd=dSrWr^rBrrrrRs zConditionalRow.clear)NT)T)NT)NT) rrrrrrrVr rCrFrGrRrXrrr;rrYs# 3 (   "rYcs@eZdZdZfddZddZddZdd Zd d ZZ S) AppendRowaGoogle Cloud Bigtable Row for sending append mutations. These mutations are intended to augment the value of an existing cell and uses the methods: * :meth:`append_cell_value` * :meth:`increment_cell_value` The first works by appending bytes and the second by incrementing an integer (stored in the cell as 8 bytes). In either case, if the cell is empty, assumes the default empty value (empty string for bytes or and 0 for integer). :type row_key: bytes :param row_key: The key for the current row. :type table: :class:`Table ` :param table: The table that owns the row. cstt|||g|_dSr)r9rbr _rule_pb_listr r;rrrszAppendRow.__init__cCs|jdd=dS)z?Removes all currently accumulated modifications on current row.N)rcrBrrrrRszAppendRow.clearcCs0t|}t|}tj|||d}|j|dS)aAppends a value to an existing cell. .. note:: This method adds a read-modify rule protobuf to the accumulated read-modify rules on this row, but does not make an API request. To actually send an API request (with the rules) 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 :param value: The value to append to the existing value in the cell. If the targeted cell is unset, it will be treated as containing the empty string. )rrZ append_valueNrr%ZReadModifyWriteRulercr')r r(r)rrule_pbrrrappend_cell_valueszAppendRow.append_cell_valuecCs(t|}tj|||d}|j|dS)aIncrements a value in an existing cell. Assumes the value in the cell is stored as a 64 bit integer serialized to bytes. .. note:: This method adds a read-modify rule protobuf to the accumulated read-modify rules on this row, but does not make an API request. To actually send an API request (with the rules) 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 int_value: int :param int_value: The value to increment the existing value in the cell by. If the targeted cell is unset, it will be treated as containing a zero. Otherwise, the targeted cell must contain an 8-byte value (interpreted as a 64-bit big-endian signed integer), or the entire request will fail. )rrZincrement_amountNrd)r r(r)Z int_valuererrrincrement_cell_valueszAppendRow.increment_cell_valuecCspt|j}|dkriS|tkr.td|tftj|jj|j|jd}|jj j }|j ||j }|t|S)a0Makes a ``ReadModifyWriteRow`` API request. This commits modifications made by :meth:`append_cell_value` and :meth:`increment_cell_value`. If no modifications were made, makes no API request and just returns ``{}``. Modifies a row atomically, reading the latest existing timestamp / value from the specified columns and writing a new value by appending / incrementing. The new cell created uses either the current server time or the highest timestamp of a cell in that column (if it exceeds the server time). After committing the accumulated mutations, resets the local mutations. .. code:: python >>> append_row.commit() { u'col-fam-id': { b'col-name1': [ (b'cell-val', datetime.datetime(...)), (b'cell-val-newer', datetime.datetime(...)), ], b'col-name2': [ (b'altcol-cell-val', datetime.datetime(...)), ], }, u'col-fam-id2': { b'col-name3-but-other-fam': [ (b'foo', datetime.datetime(...)), ], }, } :rtype: dict :returns: The new contents of all modified cells. Returned as a dictionary of column families, each of which holds a dictionary of columns. Each column contains a list of cells modified. Each cell is represented with a two-tuple with the value (in bytes) and the timestamp for the cell. :raises: :class:`ValueError ` if the number of mutations exceeds the :data:`MAX_MUTATIONS`. rz:%d total append mutations exceed the maximum allowable %d.)rHr rules)rIrcrJrKrLZReadModifyWriteRowRequestr rMr rNrOrPZReadModifyWriteRowrQrR_parse_rmw_row_response)r rSrTrU row_responserrrrVs$,  zAppendRow.commit) rrrrrrRrfrgrVrXrrr;rrbs   %rbcCs*i}|jjD]}t|\}}|||<q |S)a8Parses the response to a ``ReadModifyWriteRow`` request. :type row_response: :class:`.data_v2_pb2.Row` :param row_response: The response row (with only modified cells) from a ``ReadModifyWriteRow`` request. :rtype: dict :returns: The new contents of all modified cells. Returned as a dictionary of column families, each of which holds a dictionary of columns. Each column contains a list of cells modified. Each cell is represented with a two-tuple with the value (in bytes) and the timestamp for the cell. For example: .. code:: python { u'col-fam-id': { b'col-name1': [ (b'cell-val', datetime.datetime(...)), (b'cell-val-newer', datetime.datetime(...)), ], b'col-name2': [ (b'altcol-cell-val', datetime.datetime(...)), ], }, u'col-fam-id2': { b'col-name3-but-other-fam': [ (b'foo', datetime.datetime(...)), ], }, } )rowZfamilies_parse_family_pb)rjresultZ column_familyr(Z curr_familyrrrri.s !   ricCsNi}|jD]8}g||j<}|jD]}|jt|jf}||q"q |j|fS)aParses a Family protobuf into a dictionary. :type family_pb: :class:`._generated.data_pb2.Family` :param family_pb: A protobuf :rtype: tuple :returns: A string and dictionary. The string is the name of the column family and the dictionary has column names (within the family) as keys and cell lists as values. Each cell is represented with a two-tuple with the value (in bytes) and the timestamp for the cell. For example: .. code:: python { b'col-name1': [ (b'cell-val', datetime.datetime(...)), (b'cell-val-newer', datetime.datetime(...)), ], b'col-name2': [ (b'altcol-cell-val', datetime.datetime(...)), ], } )r4Z qualifiercellsrrrr'rM)Z family_pbrmr)rncellZval_pairrrrrlVs  rl)rstructr"Zgcloud._helpersrrrZgcloud.bigtable._generatedrr%rrLStructpackr$rJr7rrr8rYrbrirlrrrrs(      #;s&(