google-cloud-bigtable 2.42.0__tar.gz → 2.44.0__tar.gz

{google_cloud_bigtable-2.42.0/google_cloud_bigtable.egg-info → google_cloud_bigtable-2.44.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: google-cloud-bigtable
-Version: 2.42.0
+Version: 2.44.0
 Summary: Google Cloud Bigtable API client library
 Home-page: https://github.com/googleapis/google-cloud-python/tree/main/packages/google-cloud-bigtable
 Author: Google LLC
@@ -21,7 +21,7 @@ Classifier: Operating System :: OS Independent
 Classifier: Topic :: Internet
 Requires-Python: >=3.10
 License-File: LICENSE
-Requires-Dist: google-api-core[grpc]<3.0.0,>=2.25.0
+Requires-Dist: google-api-core[grpc]<3.0.0,>=2.28.0
 Requires-Dist: google-auth!=2.24.0,!=2.25.0,<3.0.0,>=2.14.1
 Requires-Dist: grpcio<2.0.0,>=1.59.0
 Requires-Dist: grpcio<2.0.0,>=1.75.1; python_version >= "3.14"

{google_cloud_bigtable-2.42.0 → google_cloud_bigtable-2.44.0}/google/cloud/bigtable/batcher.py

@@ -186,6 +186,13 @@ class MutationsBatcher(object):
 
     Note on thread safety: The same :class:`MutationBatcher` cannot be shared by multiple end-user threads.
 
+    .. warning::
+
+       If using ``MutationsBatcher``, please ensure you are using
+       ``google-cloud-bigtable >= 2.42.0``, or consider migrating to the
+       batcher provided by the synchronous/asynchronous data client
+       (:mod:`google.cloud.bigtable.data`).
+
     :type table: class
     :param table: class:`~google.cloud.bigtable.table.Table`.
 

{google_cloud_bigtable-2.42.0 → google_cloud_bigtable-2.44.0}/google/cloud/bigtable/gapic_version.py

@@ -13,4 +13,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-__version__ = "2.42.0"  # {x-release-please-version}
+__version__ = "2.44.0"  # {x-release-please-version}

{google_cloud_bigtable-2.42.0 → google_cloud_bigtable-2.44.0}/google/cloud/bigtable/row.py

@@ -14,17 +14,16 @@
 
 """User-friendly container for Google Cloud Bigtable Row."""
 
-import struct
-
+from google.api_core.exceptions import GoogleAPICallError
 from google.cloud._helpers import (
     _datetime_from_microseconds,  # type: ignore
     _microseconds_from_datetime,  # type: ignore
     _to_bytes,  # type: ignore
 )
+from google.rpc import code_pb2, status_pb2
 
-from google.cloud.bigtable_v2.types import data as data_v2_pb2
-
-_PACK_I64 = struct.Struct(">q").pack
+from google.cloud.bigtable.data import mutations
+from google.cloud.bigtable.data import read_modify_write_rules as rmw_rules
 
 MAX_MUTATIONS = 100000
 """The maximum number of mutations that a row can accumulate."""
@@ -158,26 +157,21 @@ class _SetDeleteRow(Row):
         :param state: (Optional) The state that is passed along to
                       :meth:`_get_mutations`.
         """
-        column = _to_bytes(column)
-        if isinstance(value, int):
-            value = _PACK_I64(value)
-        value = _to_bytes(value)
         if timestamp is None:
-            # Use -1 for current Bigtable server time.
-            timestamp_micros = -1
+            # Use current Bigtable server time.
+            timestamp_micros = mutations._SERVER_SIDE_TIMESTAMP
         else:
             timestamp_micros = _microseconds_from_datetime(timestamp)
             # Truncate to millisecond granularity.
             timestamp_micros -= timestamp_micros % 1000
 
-        mutation_val = data_v2_pb2.Mutation.SetCell(
-            family_name=column_family_id,
-            column_qualifier=column,
+        mutation = mutations.SetCell(
+            family=column_family_id,
+            qualifier=column,
+            new_value=value,
             timestamp_micros=timestamp_micros,
-            value=value,
         )
-        mutation_pb = data_v2_pb2.Mutation(set_cell=mutation_val)
-        self._get_mutations(state).append(mutation_pb)
+        self._get_mutations(state).append(mutation)
 
     def _delete(self, state=None):
         """Helper for :meth:`delete`
@@ -192,9 +186,7 @@ class _SetDeleteRow(Row):
         :param state: (Optional) The state that is passed along to
                       :meth:`_get_mutations`.
         """
-        mutation_val = data_v2_pb2.Mutation.DeleteFromRow()
-        mutation_pb = data_v2_pb2.Mutation(delete_from_row=mutation_val)
-        self._get_mutations(state).append(mutation_pb)
+        self._get_mutations(state).append(mutations.DeleteAllFromRow())
 
     def _delete_cells(self, column_family_id, columns, time_range=None, state=None):
         """Helper for :meth:`delete_cell` and :meth:`delete_cells`.
@@ -221,33 +213,30 @@ class _SetDeleteRow(Row):
         :param state: (Optional) The state that is passed along to
                       :meth:`_get_mutations`.
         """
-        mutations_list = self._get_mutations(state)
         if columns is self.ALL_COLUMNS:
-            mutation_val = data_v2_pb2.Mutation.DeleteFromFamily(
-                family_name=column_family_id
+            self._get_mutations(state).append(
+                mutations.DeleteAllFromFamily(family_to_delete=column_family_id)
             )
-            mutation_pb = data_v2_pb2.Mutation(delete_from_family=mutation_val)
-            mutations_list.append(mutation_pb)
         else:
-            delete_kwargs = {}
-            if time_range is not None:
-                delete_kwargs["time_range"] = time_range.to_pb()
+            timestamps = time_range._to_dict() if time_range else {}
+            start_timestamp_micros = timestamps.get("start_timestamp_micros")
+            end_timestamp_micros = timestamps.get("end_timestamp_micros")
 
             to_append = []
             for column in columns:
                 column = _to_bytes(column)
-                # time_range will never change if present, but the rest of
-                # delete_kwargs will
-                delete_kwargs.update(
-                    family_name=column_family_id, column_qualifier=column
+                to_append.append(
+                    mutations.DeleteRangeFromColumn(
+                        family=column_family_id,
+                        qualifier=column,
+                        start_timestamp_micros=start_timestamp_micros,
+                        end_timestamp_micros=end_timestamp_micros,
+                    )
                 )
-                mutation_val = data_v2_pb2.Mutation.DeleteFromColumn(**delete_kwargs)
-                mutation_pb = data_v2_pb2.Mutation(delete_from_column=mutation_val)
-                to_append.append(mutation_pb)
 
             # We don't add the mutations until all columns have been
             # processed without error.
-            mutations_list.extend(to_append)
+            self._get_mutations(state).extend(to_append)
 
 
 class DirectRow(_SetDeleteRow):
@@ -285,7 +274,7 @@ class DirectRow(_SetDeleteRow):
 
     def __init__(self, row_key, table=None):
         super(DirectRow, self).__init__(row_key, table)
-        self._pb_mutations = []
+        self._mutations = []
 
     def _get_mutations(self, state=None):  # pylint: disable=unused-argument
         """Gets the list of mutations for a given state.
@@ -300,7 +289,12 @@ class DirectRow(_SetDeleteRow):
         :rtype: list
         :returns: The list to add new mutations to (for the current state).
         """
-        return self._pb_mutations
+        return self._mutations
+
+    def _get_mutation_pbs(self):
+        """Gets the list of mutation protos."""
+
+        return [mut._to_pb() for mut in self._get_mutations()]
 
     def get_mutations_size(self):
         """Gets the total mutations size for current row
@@ -314,7 +308,7 @@ class DirectRow(_SetDeleteRow):
         """
 
         mutation_size = 0
-        for mutation in self._get_mutations():
+        for mutation in self._get_mutation_pbs():
             mutation_size += mutation._pb.ByteSize()
 
         return mutation_size
@@ -449,7 +443,8 @@ class DirectRow(_SetDeleteRow):
     def commit(self):
         """Makes a ``MutateRow`` API request.
 
-        If no mutations have been created in the row, no request is made.
+        If no mutations have been created in the row, no request is made and a
+        ValueError is raised instead.
 
         Mutations are applied atomically and in order, meaning that earlier
         mutations can be masked / negated by later ones. Cells already present
@@ -468,14 +463,30 @@ class DirectRow(_SetDeleteRow):
         :rtype: :class:`~google.rpc.status_pb2.Status`
         :returns: A response status (`google.rpc.status_pb2.Status`)
                   representing success or failure of the row committed.
-        :raises: :exc:`~.table.TooManyMutationsError` if the number of
-                 mutations is greater than 100,000.
+        :raises: ValueError: if no mutations have been created in the row
+                 or if the number of mutations is greater than 100,000.
         """
-        response = self._table.mutate_rows([self])
-
-        self.clear()
+        num_mutations = len(self._get_mutations())
+        if num_mutations > MAX_MUTATIONS:
+            raise ValueError(
+                "Number of mutations exceeds the maximum "
+                "allowable %d." % (MAX_MUTATIONS,)
+            )
 
-        return response[0]
+        try:
+            self._table._table_impl.mutate_row(self.row_key, self._get_mutations())
+            return status_pb2.Status(code=code_pb2.OK)
+        except GoogleAPICallError as e:
+            # If the RPC call returns an error, extract the error into a status object, if possible.
+            return status_pb2.Status(
+                code=e.grpc_status_code.value[0]
+                if e.grpc_status_code is not None
+                else code_pb2.UNKNOWN,
+                message=e.message,
+                details=getattr(e, "details", []),
+            )
+        finally:
+            self.clear()
 
     def clear(self):
         """Removes all currently accumulated mutations on the current row.
@@ -487,7 +498,7 @@ class DirectRow(_SetDeleteRow):
             :end-before: [END bigtable_api_row_clear]
             :dedent: 4
         """
-        del self._pb_mutations[:]
+        del self._mutations[:]
 
 
 class ConditionalRow(_SetDeleteRow):
@@ -598,17 +609,15 @@ class ConditionalRow(_SetDeleteRow):
                 % (MAX_MUTATIONS, num_true_mutations, num_false_mutations)
             )
 
-        data_client = self._table._instance._client.table_data_client
-        resp = data_client.check_and_mutate_row(
-            table_name=self._table.name,
+        table = self._table._table_impl
+        resp = table.check_and_mutate_row(
             row_key=self._row_key,
-            predicate_filter=self._filter.to_pb(),
-            app_profile_id=self._table._app_profile_id,
-            true_mutations=true_mutations,
-            false_mutations=false_mutations,
+            predicate=self._filter,
+            true_case_mutations=true_mutations,
+            false_case_mutations=false_mutations,
         )
         self.clear()
-        return resp.predicate_matched
+        return resp
 
     # pylint: disable=arguments-differ
     def set_cell(self, column_family_id, column, value, timestamp=None, state=True):
@@ -798,7 +807,7 @@ class AppendRow(Row):
 
     def __init__(self, row_key, table):
         super(AppendRow, self).__init__(row_key, table)
-        self._rule_pb_list = []
+        self._rule_list = []
 
     def clear(self):
         """Removes all currently accumulated modifications on current row.
@@ -810,7 +819,7 @@ class AppendRow(Row):
             :end-before: [END bigtable_api_row_clear]
             :dedent: 4
         """
-        del self._rule_pb_list[:]
+        del self._rule_list[:]
 
     def append_cell_value(self, column_family_id, column, value):
         """Appends a value to an existing cell.
@@ -843,12 +852,11 @@ class AppendRow(Row):
                       the targeted cell is unset, it will be treated as
                       containing the empty string.
         """
-        column = _to_bytes(column)
-        value = _to_bytes(value)
-        rule_pb = data_v2_pb2.ReadModifyWriteRule(
-            family_name=column_family_id, column_qualifier=column, append_value=value
+        self._rule_list.append(
+            rmw_rules.AppendValueRule(
+                family=column_family_id, qualifier=column, append_value=value
+            )
         )
-        self._rule_pb_list.append(rule_pb)
 
     def increment_cell_value(self, column_family_id, column, int_value):
         """Increments a value in an existing cell.
@@ -887,13 +895,11 @@ class AppendRow(Row):
                           big-endian signed integer), or the entire request
                           will fail.
         """
-        column = _to_bytes(column)
-        rule_pb = data_v2_pb2.ReadModifyWriteRule(
-            family_name=column_family_id,
-            column_qualifier=column,
-            increment_amount=int_value,
+        self._rule_list.append(
+            rmw_rules.IncrementRule(
+                family=column_family_id, qualifier=column, increment_amount=int_value
+            )
         )
-        self._rule_pb_list.append(rule_pb)
 
     def commit(self):
         """Makes a ``ReadModifyWriteRow`` API request.
@@ -926,7 +932,7 @@ class AppendRow(Row):
         :raises: :class:`ValueError <exceptions.ValueError>` if the number of
                  mutations exceeds the :data:`MAX_MUTATIONS`.
         """
-        num_mutations = len(self._rule_pb_list)
+        num_mutations = len(self._rule_list)
         if num_mutations == 0:
             return {}
         if num_mutations > MAX_MUTATIONS:
@@ -935,12 +941,10 @@ class AppendRow(Row):
                 "allowable %d." % (num_mutations, MAX_MUTATIONS)
             )
 
-        data_client = self._table._instance._client.table_data_client
-        row_response = data_client.read_modify_write_row(
-            table_name=self._table.name,
+        table = self._table._table_impl
+        row_response = table.read_modify_write_row(
             row_key=self._row_key,
-            rules=self._rule_pb_list,
-            app_profile_id=self._table._app_profile_id,
+            rules=self._rule_list,
         )
 
         # Reset modifications after commit-ing request.
@@ -984,47 +988,13 @@ def _parse_rmw_row_response(row_response):
                   }
     """
     result = {}
-    for column_family in row_response.row.families:
-        column_family_id, curr_family = _parse_family_pb(column_family)
-        result[column_family_id] = curr_family
+    for cell in row_response.cells:
+        column_family = result.setdefault(cell.family, {})
+        column = column_family.setdefault(cell.qualifier, [])
+        column.append((cell.value, _datetime_from_microseconds(cell.timestamp_micros)))
     return result
 
 
-def _parse_family_pb(family_pb):
-    """Parses 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(...)),
-                      ],
-                  }
-    """
-    result = {}
-    for column in family_pb.columns:
-        result[column.qualifier] = cells = []
-        for cell in column.cells:
-            val_pair = (cell.value, _datetime_from_microseconds(cell.timestamp_micros))
-            cells.append(val_pair)
-
-    return family_pb.name, result
-
-
 class PartialRowData(object):
     """Representation of partial row in a Google Cloud Bigtable Table.
 

google_cloud_bigtable-2.44.0/google/cloud/bigtable/row_filters.py

@@ -0,0 +1,238 @@
+# Copyright 2016 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Filters for Google Cloud Bigtable Row classes."""
+
+import struct
+
+from google.cloud.bigtable.data.row_filters import (  # noqa: F401
+    ApplyLabelFilter,
+    BlockAllFilter,
+    CellsColumnLimitFilter,
+    CellsRowLimitFilter,
+    CellsRowOffsetFilter,
+    ColumnQualifierRegexFilter,
+    FamilyNameRegexFilter,
+    PassAllFilter,
+    RowFilter,
+    RowFilterChain,
+    RowFilterUnion,
+    RowKeyRegexFilter,
+    RowSampleFilter,
+    SinkFilter,
+    StripValueTransformerFilter,
+    TimestampRange,
+    ValueBitmaskFilter,
+    ValueRangeFilter,
+    ValueRegexFilter,
+    _BoolFilter,
+    _CellCountFilter,
+    _FilterCombination,
+    _RegexFilter,
+)
+from google.cloud.bigtable.data.row_filters import (
+    ColumnRangeFilter as BaseColumnRangeFilter,
+)
+from google.cloud.bigtable.data.row_filters import (
+    ConditionalRowFilter as BaseConditionalRowFilter,
+)
+from google.cloud.bigtable.data.row_filters import (
+    TimestampRangeFilter as BaseTimestampRangeFilter,
+)
+
+_PACK_I64 = struct.Struct(">q").pack
+
+
+def _deprecated_to_pb(self):
+    import warnings
+
+    warnings.warn(
+        "`to_pb()` is deprecated and will be removed in a future release. "
+        "Filter objects should be passed directly to Bigtable client read and query "
+        "methods without manual protobuf conversion.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return self._to_pb()
+
+
+# Provide to_pb alias with DeprecationWarning for backwards compatibility with legacy client code
+RowFilter.to_pb = _deprecated_to_pb  # type: ignore[attr-defined]
+TimestampRange.to_pb = _deprecated_to_pb  # type: ignore[attr-defined]
+
+
+class _MappableAttributesMixin:
+    """
+    Mixin for classes that need some of their attribute names remapped.
+
+    This is for taking some of the classes from the data client row filters
+    that are 1:1 with their legacy client counterparts but with some of their
+    attributes renamed. To use in a class, override the base class with this mixin
+    class and define a map _attribute_map from legacy client attributes to data client
+    attributes.
+
+    Attributes are remapped and redefined in __init__ as well as getattr/setattr.
+    """
+
+    def __init__(self, *args, **kwargs):
+        new_kwargs = {self._attribute_map.get(k, k): v for (k, v) in kwargs.items()}
+        super(_MappableAttributesMixin, self).__init__(*args, **new_kwargs)
+
+    def __getattr__(self, name):
+        if name not in self._attribute_map:
+            raise AttributeError
+        return getattr(self, self._attribute_map[name])
+
+    def __setattr__(self, name, value):
+        attribute = self._attribute_map.get(name, name)
+        super(_MappableAttributesMixin, self).__setattr__(attribute, value)
+
+
+# The classes defined below are to provide constructors and members
+# that have an interface that does not match the one used by the data
+# client, for backwards compatibility purposes.
+
+# Each underscored class is an ABC. Make them into classes that can be
+# instantiated with a placeholder to_dict method for consistency.
+
+
+class TimestampRangeFilter(BaseTimestampRangeFilter):
+    """Row filter that limits cells to a range of time.
+
+    :type range_: :class:`TimestampRange`
+    :param range_: Range of time that cells should match against.
+    """
+
+    def __init__(self, range_):
+        self.range_ = range_
+
+
+class ExactValueFilter(ValueRegexFilter):
+    """Row filter for an exact value.
+
+
+    :type value: bytes or str or int
+    :param value:
+        a literal string encodable as ASCII, or the
+        equivalent bytes, or an integer (which will be packed into 8-bytes).
+    """
+
+    def __init__(self, value):
+        if isinstance(value, int):
+            value = _PACK_I64(value)
+        super(ExactValueFilter, self).__init__(value)
+
+
+class ColumnRangeFilter(_MappableAttributesMixin, BaseColumnRangeFilter):
+    """A row filter to restrict to a range of columns.
+
+    Both the start and end column can be included or excluded in the range.
+    By default, we include them both, but this can be changed with optional
+    flags.
+
+    :type column_family_id: str
+    :param column_family_id: The column family that contains the columns. Must
+                             be of the form ``[_a-zA-Z0-9][-_.a-zA-Z0-9]*``.
+
+    :type start_column: bytes
+    :param start_column: The start of the range of columns. If no value is
+                         used, the backend applies no upper bound to the
+                         values.
+
+    :type end_column: bytes
+    :param end_column: The end of the range of columns. If no value is used,
+                       the backend applies no upper bound to the values.
+
+    :type inclusive_start: bool
+    :param inclusive_start: Boolean indicating if the start column should be
+                            included in the range (or excluded). Defaults
+                            to :data:`True` if ``start_column`` is passed and
+                            no ``inclusive_start`` was given.
+
+    :type inclusive_end: bool
+    :param inclusive_end: Boolean indicating if the end column should be
+                          included in the range (or excluded). Defaults
+                          to :data:`True` if ``end_column`` is passed and
+                          no ``inclusive_end`` was given.
+
+    :raises: :class:`ValueError <exceptions.ValueError>` if ``inclusive_start``
+             is set but no ``start_column`` is given or if ``inclusive_end``
+             is set but no ``end_column`` is given
+    """
+
+    _attribute_map = {
+        "column_family_id": "family_id",
+        "start_column": "start_qualifier",
+        "end_column": "end_qualifier",
+    }
+
+
+class ConditionalRowFilter(_MappableAttributesMixin, BaseConditionalRowFilter):
+    """Conditional row filter which exhibits ternary behavior.
+
+    Executes one of two filters based on another filter. If the ``base_filter``
+    returns any cells in the row, then ``true_filter`` is executed. If not,
+    then ``false_filter`` is executed.
+
+    .. note::
+
+        The ``base_filter`` does not execute atomically with the true and false
+        filters, which may lead to inconsistent or unexpected results.
+
+        Additionally, executing a :class:`ConditionalRowFilter` has poor
+        performance on the server, especially when ``false_filter`` is set.
+
+    :type base_filter: :class:`RowFilter`
+    :param base_filter: The filter to condition on before executing the
+                        true/false filters.
+
+    :type true_filter: :class:`RowFilter`
+    :param true_filter: (Optional) The filter to execute if there are any cells
+                        matching ``base_filter``. If not provided, no results
+                        will be returned in the true case.
+
+    :type false_filter: :class:`RowFilter`
+    :param false_filter: (Optional) The filter to execute if there are no cells
+                         matching ``base_filter``. If not provided, no results
+                         will be returned in the false case.
+    """
+
+    _attribute_map = {"base_filter": "predicate_filter"}
+
+
+__all__ = (
+    "RowFilter",
+    "SinkFilter",
+    "PassAllFilter",
+    "BlockAllFilter",
+    "RowKeyRegexFilter",
+    "RowSampleFilter",
+    "FamilyNameRegexFilter",
+    "ColumnQualifierRegexFilter",
+    "TimestampRange",
+    "TimestampRangeFilter",
+    "ColumnRangeFilter",
+    "ValueRegexFilter",
+    "ExactValueFilter",
+    "ValueRangeFilter",
+    "ValueBitmaskFilter",
+    "CellsRowOffsetFilter",
+    "CellsRowLimitFilter",
+    "CellsColumnLimitFilter",
+    "StripValueTransformerFilter",
+    "ApplyLabelFilter",
+    "RowFilterChain",
+    "RowFilterUnion",
+    "ConditionalRowFilter",
+)

{google_cloud_bigtable-2.42.0 → google_cloud_bigtable-2.44.0}/google/cloud/bigtable/table.py

@@ -873,6 +873,13 @@ class Table(object):
             :end-before: [END bigtable_api_mutations_batcher]
             :dedent: 4
 
+        .. warning::
+
+           If using ``MutationsBatcher``, please ensure you are using
+           ``google-cloud-bigtable >= 2.42.0``, or consider migrating to the
+           batcher provided by the synchronous/asynchronous data client
+           (:mod:`google.cloud.bigtable.data`).
+
         :type flush_count: int
         :param flush_count: (Optional) Maximum number of rows per batch. If it
                 reaches the max number of rows it calls finish_batch() to
@@ -1328,7 +1335,7 @@ def _create_row_request(
         raise ValueError("Row range and row set cannot be set simultaneously")
 
     if filter_ is not None:
-        request_kwargs["filter"] = filter_.to_pb()
+        request_kwargs["filter"] = filter_._to_pb()
     if limit is not None:
         request_kwargs["rows_limit"] = limit
     if app_profile_id is not None:
@@ -1367,7 +1374,7 @@ def _compile_mutation_entries(table_name, rows):
     for row in rows:
         _check_row_table_name(table_name, row)
         _check_row_type(row)
-        mutations = row._get_mutations()
+        mutations = row._get_mutation_pbs()
         entries.append(entry_klass(row_key=row.row_key, mutations=mutations))
         mutations_count += len(mutations)
 

{google_cloud_bigtable-2.42.0 → google_cloud_bigtable-2.44.0}/google/cloud/bigtable_admin/__init__.py

@@ -142,6 +142,7 @@ from google.cloud.bigtable_admin_v2.types.instance import (
 )
 from google.cloud.bigtable_admin_v2.types.table import (
     AuthorizedView,
+    AvroSchema,
     Backup,
     BackupInfo,
     ChangeStreamConfig,
@@ -270,6 +271,7 @@ __all__ = (
     "LogicalView",
     "MaterializedView",
     "AuthorizedView",
+    "AvroSchema",
     "Backup",
     "BackupInfo",
     "ChangeStreamConfig",

{google_cloud_bigtable-2.42.0 → google_cloud_bigtable-2.44.0}/google/cloud/bigtable_admin/gapic_version.py

@@ -13,4 +13,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-__version__ = "2.42.0"  # {x-release-please-version}
+__version__ = "2.44.0"  # {x-release-please-version}