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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: google-cloud-bigtable
-Version: 2.40.0
+Version: 2.42.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,15 +21,18 @@ 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.24.2
+Requires-Dist: google-api-core[grpc]<3.0.0,>=2.25.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"
 Requires-Dist: proto-plus<2.0.0,>=1.26.1
 Requires-Dist: protobuf<8.0.0,>=6.33.5
+Requires-Dist: google-cloud-monitoring<3.0.0dev,>=2.0.0
 Requires-Dist: google-cloud-core<3.0.0,>=2.0.0
 Requires-Dist: grpc-google-iam-v1<1.0.0,>=0.14.2
-Requires-Dist: google-crc32c<2.0.0dev,>=1.6.0
+Requires-Dist: google-crc32c<2.0.0,>=1.6.0
+Requires-Dist: opentelemetry-api<2.0.0dev,>=1.0.0
+Requires-Dist: opentelemetry-sdk<2.0.0dev,>=1.0.0
 Provides-Extra: libcst
 Requires-Dist: libcst>=0.2.5; extra == "libcst"
 Dynamic: author

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

@@ -174,10 +174,15 @@ class MutationsBatcher(object):
     request.
 
     This class is not suited for usage in systems where each mutation
-    must be guaranteed to be sent, since calling mutate may only result in an
-    in-memory change. In a case of a system crash, any :class:`DirectRow` remaining in
-    memory will not necessarily be sent to the service, even after the
-    completion of the :func:`mutate()` method.
+    must be guaranteed to be sent, since calling :func:`mutate()` may only
+    result in an in-memory change. Rows are only sent to the service when a size
+    limit is reached, when :func:`flush()` is called explicitly, or when the
+    batcher is closed (:func:`close()` is also registered to run at interpreter
+    exit). There is no time-based background flush. As a result, if the process
+    terminates abruptly -- e.g. a crash, ``SIGKILL``, or ``os._exit`` where the
+    ``atexit`` handler never runs -- any :class:`DirectRow` still buffered in
+    memory is silently dropped and never sent, even after :func:`mutate()`
+    returned.
 
     Note on thread safety: The same :class:`MutationBatcher` cannot be shared by multiple end-user threads.
 
@@ -196,8 +201,9 @@ class MutationsBatcher(object):
         (5 MB).
 
     :type flush_interval: float
-    :param flush_interval: (Optional) The interval (in seconds) between asynchronous flush.
-        Default is 1 second.
+    :param flush_interval: (Deprecated) No longer used. Retained only for
+        backwards compatibility. There is no time-based background flush; see the
+        class docstring for when rows are sent.
 
     :type batch_completed_callback: Callable[list:[`~google.rpc.status_pb2.Status`]] = None
     :param batch_completed_callback: (Optional) A callable for handling responses
@@ -219,8 +225,12 @@ class MutationsBatcher(object):
         self.table = table
         self._executor = concurrent.futures.ThreadPoolExecutor()
         atexit.register(self.close)
-        self._timer = threading.Timer(flush_interval, self.flush)
-        self._timer.start()
+        # ``flush_interval`` is retained for backwards compatibility but is no
+        # longer used: the previous background ``threading.Timer`` was one-shot
+        # (never re-armed), so it fired at most once and could silently drop the
+        # rows it dequeued if that single flush raised on the timer thread.
+        # Flushing now happens only on size thresholds, explicit ``flush()``,
+        # or ``close()`` (also registered via ``atexit``).
         self.flow_control = _FlowControl(
             max_mutations=MAX_OUTSTANDING_ELEMENTS,
             max_mutation_bytes=MAX_OUTSTANDING_BYTES,
@@ -350,6 +360,26 @@ class MutationsBatcher(object):
         processed_rows = self.futures_mapping[future]
         self.flow_control.release(processed_rows)
         del self.futures_mapping[future]
+        # Surface any exception raised inside the async flush. Without this, an
+        # exception raised by ``_flush_rows`` (e.g. a non-retryable RPC error, a
+        # retry deadline, or a response-count mismatch) would be stored on the
+        # future and silently discarded, so the failed mutations would never be
+        # reported to the user -- effectively silent data loss. Per-row errors
+        # from a successful RPC are already recorded in ``self.exceptions`` by
+        # ``_flush_rows``; here the whole batch failed with a single exception,
+        # so record it once per row in the batch to keep the reported error
+        # count aligned with the number of affected mutations.
+        #
+        # A cancelled future is "done", so this callback still runs for it, but
+        # ``future.exception()`` would raise ``CancelledError``. Nothing here
+        # cancels futures today, but guard against it so the callback stays
+        # correct if cancellation is ever introduced.
+        if future.cancelled():
+            return
+        exc = future.exception()
+        if exc is not None:
+            for _ in range(processed_rows.rows_count):
+                self.exceptions.put(exc)
 
     def _row_fits_in_batch(self, row, batch_info):
         """Checks if a row can fit in the current batch.
@@ -405,7 +435,19 @@ class MutationsBatcher(object):
         :raises:
             * :exc:`.batcherMutationsBatchError` if there's any error in the mutations.
         """
-        self.flush()
+        try:
+            self.flush()
+        except MutationsBatchError as exc:
+            for e in exc.exc:
+                self.exceptions.put(e)
+        except Exception as exc:
+            # A failure in this final synchronous flush must not abort cleanup.
+            # If it propagated here it would skip the executor shutdown (leaving
+            # in-flight async flushes un-awaited) and skip draining
+            # self.exceptions, masking every error already captured from
+            # earlier async flushes -- silently discarding those failures.
+            # Record it like any other batch failure and continue.
+            self.exceptions.put(exc)
         self._executor.shutdown(wait=True)
         atexit.unregister(self.close)
         if self.exceptions.qsize() > 0:

{google_cloud_bigtable-2.40.0 → google_cloud_bigtable-2.42.0}/google/cloud/bigtable/client.py

@@ -28,6 +28,7 @@ In the hierarchy of API concepts
   :class:`~google.cloud.bigtable.row.Row` (and all the cells in the row)
 """
 
+import copy
 import os
 import warnings
 
@@ -37,7 +38,7 @@ from google.auth.credentials import AnonymousCredentials  # type: ignore
 from google.cloud.client import ClientWithProject  # type: ignore
 from google.cloud.environment_vars import BIGTABLE_EMULATOR  # type: ignore
 
-from google.cloud import bigtable, bigtable_admin_v2, bigtable_v2
+from google.cloud import bigtable, bigtable_admin_v2
 from google.cloud.bigtable.cluster import _CLUSTER_NAME_RE, Cluster
 from google.cloud.bigtable.instance import Instance
 from google.cloud.bigtable_admin_v2.services.bigtable_instance_admin.transports import (
@@ -47,7 +48,6 @@ from google.cloud.bigtable_admin_v2.services.bigtable_table_admin.transports imp
     BigtableTableAdminGrpcTransport,
 )
 from google.cloud.bigtable_admin_v2.types import instance
-from google.cloud.bigtable_v2.services.bigtable.transports import BigtableGrpcTransport
 
 INSTANCE_TYPE_PRODUCTION = instance.Instance.Type.PRODUCTION
 INSTANCE_TYPE_DEVELOPMENT = instance.Instance.Type.DEVELOPMENT
@@ -60,7 +60,6 @@ DATA_SCOPE = "https://www.googleapis.com/auth/bigtable.data"
 READ_ONLY_SCOPE = "https://www.googleapis.com/auth/bigtable.data.readonly"
 """Scope for reading table data."""
 
-_DEFAULT_BIGTABLE_EMULATOR_CLIENT = "google-cloud-bigtable-emulator"
 _GRPC_CHANNEL_OPTIONS = (
     ("grpc.max_send_message_length", -1),
     ("grpc.max_receive_message_length", -1),
@@ -68,6 +67,8 @@ _GRPC_CHANNEL_OPTIONS = (
     ("grpc.keepalive_timeout_ms", 10000),
 )
 
+_DEFAULT_BIGTABLE_EMULATOR_CLIENT = "google-cloud-bigtable-emulator"
+
 
 def _create_gapic_client(client_class, client_options=None, transport=None):
     def inner(self):
@@ -284,18 +285,7 @@ class Client(ClientWithProject):
         :rtype: :class:`.bigtable_v2.BigtableClient`
         :returns: A BigtableClient object.
         """
-        if self._table_data_client is None:
-            transport = self._create_gapic_client_channel(
-                bigtable_v2.BigtableClient,
-                BigtableGrpcTransport,
-            )
-            klass = _create_gapic_client(
-                bigtable_v2.BigtableClient,
-                client_options=self._client_options,
-                transport=transport,
-            )
-            self._table_data_client = klass(self)
-        return self._table_data_client
+        return self._veneer_data_client._gapic_client
 
     @property
     def table_admin_client(self):
@@ -363,6 +353,23 @@ class Client(ClientWithProject):
             self._instance_admin_client = klass(self)
         return self._instance_admin_client
 
+    @property
+    def _veneer_data_client(self):
+        """Getter for the new Data Table API."""
+        if self._table_data_client is None:
+            from google.cloud.bigtable.data import BigtableDataClient
+
+            client_info = copy.copy(self._client_info)
+            client_info.client_library_version = f"{bigtable.__version__}-data-shim"
+            self._table_data_client = BigtableDataClient(
+                project=self.project,
+                credentials=self._credentials,
+                client_options=self._client_options,
+                _client_info=client_info,
+                _disable_background_refresh=True,
+            )
+        return self._table_data_client
+
     def instance(self, instance_id, display_name=None, instance_type=None, labels=None):
         """Factory to create a instance associated with this client.
 

{google_cloud_bigtable-2.40.0 → google_cloud_bigtable-2.42.0}/google/cloud/bigtable/data/__init__.py

@@ -19,6 +19,7 @@ from google.cloud.bigtable.data._async._read_rows import _ReadRowsOperationAsync
 from google.cloud.bigtable.data._async.client import (
     AuthorizedViewAsync,
     BigtableDataClientAsync,
+    MaterializedViewAsync,
     TableAsync,
 )
 from google.cloud.bigtable.data._async.mutations_batcher import MutationsBatcherAsync
@@ -33,6 +34,7 @@ from google.cloud.bigtable.data._sync_autogen._read_rows import _ReadRowsOperati
 from google.cloud.bigtable.data._sync_autogen.client import (
     AuthorizedView,
     BigtableDataClient,
+    MaterializedView,
     Table,
 )
 from google.cloud.bigtable.data._sync_autogen.mutations_batcher import MutationsBatcher
@@ -80,10 +82,12 @@ __all__ = (
     "BigtableDataClientAsync",
     "TableAsync",
     "AuthorizedViewAsync",
+    "MaterializedViewAsync",
     "MutationsBatcherAsync",
     "BigtableDataClient",
     "Table",
     "AuthorizedView",
+    "MaterializedView",
     "MutationsBatcher",
     "RowKeySamples",
     "ReadRowsQuery",

{google_cloud_bigtable-2.40.0 → google_cloud_bigtable-2.42.0}/google/cloud/bigtable/data/_async/_mutate_rows.py

@@ -23,7 +23,7 @@ import google.cloud.bigtable.data.exceptions as bt_exceptions
 import google.cloud.bigtable_v2.types.bigtable as types_pb
 from google.cloud.bigtable.data._cross_sync import CrossSync
 from google.cloud.bigtable.data._helpers import _attempt_timeout_generator
-from google.cloud.bigtable.data._metrics import tracked_retry
+from google.cloud.bigtable.data._metrics.tracked_retry import tracked_retry
 
 # mutate_rows requests are limited to this number of mutations
 from google.cloud.bigtable.data.mutations import (
@@ -214,6 +214,18 @@ class _MutateRowsOperationAsync:
                 self._handle_entry_error(idx, exc)
             # bubble up exception to be handled by retry wrapper
             raise
+        # Any entries that were sent but never received a response entry (a
+        # successfully-closed but incomplete stream) must not be treated as
+        # successful. Record a retryable error so idempotent entries are retried
+        # and non-idempotent entries surface as failures instead of being
+        # silently dropped.
+        for idx in active_request_indices.values():
+            self._handle_entry_error(
+                idx,
+                bt_exceptions._MutateRowsIncomplete(
+                    "no response entry received for mutation"
+                ),
+            )
         # check if attempt succeeded, or needs to be retried
         if self.remaining_indices:
             # unfinished work; raise exception to trigger retry

{google_cloud_bigtable-2.40.0 → google_cloud_bigtable-2.42.0}/google/cloud/bigtable/data/_async/_read_rows.py

@@ -25,7 +25,7 @@ from google.cloud.bigtable.data._cross_sync import CrossSync
 from google.cloud.bigtable.data._helpers import (
     _attempt_timeout_generator,
 )
-from google.cloud.bigtable.data._metrics import tracked_retry
+from google.cloud.bigtable.data._metrics.tracked_retry import tracked_retry
 from google.cloud.bigtable.data.exceptions import (
     InvalidChunk,
     _ResetRow,