Added app_profile_id, legacy client shim version, and renamed

_data_client

Author: gkevinzheng

google/cloud/bigtable/client.py

@@ -292,7 +292,7 @@ def table_data_client(self):
         :rtype: :class:`.bigtable_v2.BigtableClient`
         :returns: A BigtableClient object.
         """
-        return self._data_client._gapic_client
+        return self._veneer_data_client._gapic_client
 
     @property
     def table_admin_client(self):
@@ -361,15 +361,15 @@ def instance_admin_client(self):
         return self._instance_admin_client
 
     @property
-    def _data_client(self):
+    def _veneer_data_client(self):
         """Getter for the new Data Table API."""
         if self._table_data_client is None:
             self._table_data_client = BigtableDataClient(
                 project=self.project,
                 credentials=self._credentials,
                 client_options=self._client_options,
                 _client_info=self._client_info,
-                _disable_background_channel_refresh=True,
+                _is_legacy_client=True,
             )
         return self._table_data_client
 

google/cloud/bigtable/data/_async/client.py

@@ -184,14 +184,16 @@ def __init__(
         """
         if "pool_size" in kwargs:
             warnings.warn("pool_size no longer supported")
-        if "_client_info" in kwargs:
-            # use client_info passed in from legacy client. For internal use only, for the legacy
-            # client shim.
-            self.client_info = kwargs["_client_info"]
-        else:
-            # set up client info headers for veneer library.
-            self.client_info = kwargs.get("_client_info", DEFAULT_CLIENT_INFO)
-            self.client_info.client_library_version = self._client_version()
+        
+        # Private argument, for internal use only
+        self._is_legacy_client = bool(
+            kwargs.get("_is_legacy_client", False)
+        )
+
+        # set up client info headers for veneer library. _client_info is for internal use only,
+        # for the legacy client shim.
+        self.client_info = kwargs.get("_client_info", DEFAULT_CLIENT_INFO)
+        self.client_info.client_library_version = self._client_version()
 
         # parse client options
         if type(client_options) is dict:
@@ -242,10 +244,6 @@ def __init__(
                 "is the default."
             )
         self._is_closed = CrossSync.Event()
-        # Private argument, for internal use only
-        self._disable_background_channel_refresh = bool(
-            kwargs.get("_disable_background_channel_refresh", False)
-        )
         self.transport = cast(TransportType, self._gapic_client.transport)
         # keep track of active instances to for warmup on channel refresh
         self._active_instances: Set[_WarmedInstanceKey] = set()
@@ -310,12 +308,13 @@ def api_endpoint(self) -> str:
         """
         return self._gapic_client.api_endpoint
 
-    @staticmethod
-    def _client_version() -> str:
+    def _client_version(self) -> str:
         """
         Helper function to return the client version string for this client
         """
         version_str = f"{google.cloud.bigtable.__version__}-data"
+        if self._is_legacy_client:
+            version_str += "-shim"
         if CrossSync.is_async:
             version_str += "-async"
         return version_str
@@ -339,7 +338,7 @@ def _start_background_channel_refresh(self) -> None:
             not self._channel_refresh_task
             and not self._emulator_host
             and not self._is_closed.is_set()
-            and not self._disable_background_channel_refresh
+            and not self._is_legacy_client
         ):
             # raise error if not in an event loop in async client
             CrossSync.verify_async_event_loop()

google/cloud/bigtable/data/_sync_autogen/client.py

@@ -127,11 +127,9 @@ def __init__(
         """
         if "pool_size" in kwargs:
             warnings.warn("pool_size no longer supported")
-        if "_client_info" in kwargs:
-            self.client_info = kwargs["_client_info"]
-        else:
-            self.client_info = kwargs.get("_client_info", DEFAULT_CLIENT_INFO)
-            self.client_info.client_library_version = self._client_version()
+        self._is_legacy_client = bool(kwargs.get("_is_legacy_client", False))
+        self.client_info = kwargs.get("_client_info", DEFAULT_CLIENT_INFO)
+        self.client_info.client_library_version = self._client_version()
         if type(client_options) is dict:
             client_options = client_options_lib.from_dict(client_options)
         client_options = cast(
@@ -171,9 +169,6 @@ def __init__(
                 f"The configured universe domain ({self.universe_domain}) does not match the universe domain found in the credentials ({self._credentials.universe_domain}). If you haven't configured the universe domain explicitly, `googleapis.com` is the default."
             )
         self._is_closed = CrossSync._Sync_Impl.Event()
-        self._disable_background_channel_refresh = bool(
-            kwargs.get("_disable_background_channel_refresh", False)
-        )
         self.transport = cast(TransportType, self._gapic_client.transport)
         self._active_instances: Set[_WarmedInstanceKey] = set()
         self._instance_owners: dict[_WarmedInstanceKey, Set[int]] = {}
@@ -229,10 +224,11 @@ def api_endpoint(self) -> str:
             str: The API endpoint used by the client instance."""
         return self._gapic_client.api_endpoint
 
-    @staticmethod
-    def _client_version() -> str:
+    def _client_version(self) -> str:
         """Helper function to return the client version string for this client"""
         version_str = f"{google.cloud.bigtable.__version__}-data"
+        if self._is_legacy_client:
+            version_str += "-shim"
         return version_str
 
     def _start_background_channel_refresh(self) -> None:
@@ -244,7 +240,7 @@ def _start_background_channel_refresh(self) -> None:
             not self._channel_refresh_task
             and (not self._emulator_host)
             and (not self._is_closed.is_set())
-            and (not self._disable_background_channel_refresh)
+            and (not self._is_legacy_client)
         ):
             CrossSync._Sync_Impl.verify_async_event_loop()
             self._channel_refresh_task = CrossSync._Sync_Impl.create_task(

google/cloud/bigtable/table.py

@@ -132,10 +132,13 @@ def __init__(self, table_id, instance, mutation_timeout=None, app_profile_id=Non
         self._app_profile_id = app_profile_id
         self.mutation_timeout = mutation_timeout
 
+        # TODO: Figure out which value to use for mutation_timeout after looking at how
+        # mutation_timeout is used in this class.
         self._table_impl = (
-            self._instance._client._data_client.get_table(
+            self._instance._client._veneer_data_client.get_table(
                 self._instance.instance_id,
                 self.table_id,
+                app_profile_id=app_profile_id,
             )
             if self._instance
             else None

tests/unit/data/_async/test_client.py

@@ -119,6 +119,7 @@ async def test_ctor(self):
     @CrossSync.pytest
     async def test_ctor_super_inits(self):
         from google.cloud.client import ClientWithProject
+        from google.cloud.bigtable import __version__ as bigtable_version
         from google.api_core import client_options as client_options_lib
         from google.cloud.bigtable_v2.services.bigtable.transports.base import (
             DEFAULT_CLIENT_INFO,
@@ -155,7 +156,9 @@ async def test_ctor_super_inits(self):
 
                 expected_client_info = copy.copy(DEFAULT_CLIENT_INFO)
                 expected_client_info.client_library_version = (
-                    CrossSync.DataClient._client_version()
+                    f"{bigtable_version}-data"
+                    if not CrossSync.is_async
+                    else f"{bigtable_version}-data-async"
                 )
                 assert (
                     kwargs["client_info"].to_user_agent()
@@ -174,9 +177,11 @@ async def test_ctor_super_inits(self):
                 assert kwargs["client_options"] == options_parsed
 
     @CrossSync.pytest
-    async def test_ctor_client_info(self):
+    async def test_ctor_legacy_client(self):
         from google.api_core import client_options as client_options_lib
         from google.api_core.gapic_v1.client_info import ClientInfo
+        from google.cloud.bigtable import __version__ as bigtable_version
+        import copy
 
         project = "project-id"
         credentials = AnonymousCredentials()
@@ -193,6 +198,7 @@ async def test_ctor_client_info(self):
                     client_options=options_parsed,
                     use_emulator=False,
                     _client_info=client_info,
+                    _is_legacy_client=True,
                 )
             except TypeError:
                 pass
@@ -203,7 +209,20 @@ async def test_ctor_client_info(self):
             assert kwargs["credentials"] == credentials
             assert kwargs["client_options"] == options_parsed
 
-        kwargs["client_info"] == client_info
+            expected_client_info = copy.copy(client_info)
+            expected_client_info.client_library_version = (
+                f"{bigtable_version}-data-shim"
+                if not CrossSync.is_async
+                else f"{bigtable_version}-data-shim-async"
+            )
+            assert (
+                kwargs["client_info"].to_user_agent()
+                == expected_client_info.to_user_agent()
+            )
+            assert (
+                kwargs["client_info"].to_grpc_metadata()
+                == expected_client_info.to_grpc_metadata()
+            )
 
     @CrossSync.pytest
     async def test_ctor_dict_options(self):
@@ -297,10 +316,10 @@ async def test__start_background_channel_refresh(self):
             await client.close()
 
     @CrossSync.pytest
-    async def test__start_background_channel_refresh_disable_refresh(self):
+    async def test__start_background_channel_refresh_legacy_client(self):
         client = self._make_client(
             project="project-id",
-            _disable_background_channel_refresh=True,
+            _is_legacy_client=True,
         )
         # should create background tasks for each channel
         with mock.patch.object(

tests/unit/data/_sync_autogen/test_client.py

@@ -89,6 +89,7 @@ def test_ctor(self):
 
     def test_ctor_super_inits(self):
         from google.cloud.client import ClientWithProject
+        from google.cloud.bigtable import __version__ as bigtable_version
         from google.api_core import client_options as client_options_lib
         from google.cloud.bigtable_v2.services.bigtable.transports.base import (
             DEFAULT_CLIENT_INFO,
@@ -122,7 +123,9 @@ def test_ctor_super_inits(self):
                 assert kwargs["client_options"] == options_parsed
                 expected_client_info = copy.copy(DEFAULT_CLIENT_INFO)
                 expected_client_info.client_library_version = (
-                    CrossSync._Sync_Impl.DataClient._client_version()
+                    f"{bigtable_version}-data"
+                    if not CrossSync._Sync_Impl.is_async
+                    else f"{bigtable_version}-data-async"
                 )
                 assert (
                     kwargs["client_info"].to_user_agent()
@@ -138,9 +141,11 @@ def test_ctor_super_inits(self):
                 assert kwargs["credentials"] == credentials
                 assert kwargs["client_options"] == options_parsed
 
-    def test_ctor_client_info(self):
+    def test_ctor_legacy_client(self):
         from google.api_core import client_options as client_options_lib
         from google.api_core.gapic_v1.client_info import ClientInfo
+        from google.cloud.bigtable import __version__ as bigtable_version
+        import copy
 
         project = "project-id"
         credentials = AnonymousCredentials()
@@ -157,14 +162,28 @@ def test_ctor_client_info(self):
                     client_options=options_parsed,
                     use_emulator=False,
                     _client_info=client_info,
+                    _is_legacy_client=True,
                 )
             except TypeError:
                 pass
             assert bigtable_client_init.call_count == 1
             kwargs = bigtable_client_init.call_args[1]
             assert kwargs["credentials"] == credentials
             assert kwargs["client_options"] == options_parsed
-        kwargs["client_info"] == client_info
+            expected_client_info = copy.copy(client_info)
+            expected_client_info.client_library_version = (
+                f"{bigtable_version}-data-shim"
+                if not CrossSync._Sync_Impl.is_async
+                else f"{bigtable_version}-data-shim-async"
+            )
+            assert (
+                kwargs["client_info"].to_user_agent()
+                == expected_client_info.to_user_agent()
+            )
+            assert (
+                kwargs["client_info"].to_grpc_metadata()
+                == expected_client_info.to_grpc_metadata()
+            )
 
     def test_ctor_dict_options(self):
         from google.api_core.client_options import ClientOptions
@@ -238,10 +257,8 @@ def test__start_background_channel_refresh(self):
             assert ping_and_warm.call_count == 1
             client.close()
 
-    def test__start_background_channel_refresh_disable_refresh(self):
-        client = self._make_client(
-            project="project-id", _disable_background_channel_refresh=True
-        )
+    def test__start_background_channel_refresh_legacy_client(self):
+        client = self._make_client(project="project-id", _is_legacy_client=True)
         with mock.patch.object(
             client, "_ping_and_warm_instances", CrossSync._Sync_Impl.Mock()
         ) as ping_and_warm:

tests/unit/v2_client/test_client.py

@@ -397,29 +397,29 @@ def test_client_data_client_not_initialized():
     credentials = _make_credentials()
     client = _make_client(project=PROJECT, credentials=credentials)
 
-    data_client = client._data_client
-    assert isinstance(data_client, BigtableDataClient)
-    assert client._data_client is data_client
-    assert client._data_client._disable_background_channel_refresh
+    veneer_data_client = client._veneer_data_client
+    assert isinstance(veneer_data_client, BigtableDataClient)
+    assert client._veneer_data_client is veneer_data_client
+    assert client._veneer_data_client._is_legacy_client
 
 
-def test_client_data_client_not_initialized_w_client_info():
+def test_client_veneer_data_client_not_initialized_w_client_info():
     from google.api_core.gapic_v1.client_info import ClientInfo
 
     credentials = _make_credentials()
     client_info = ClientInfo(gapic_version="1.2.3", user_agent="test-client-")
     client = _make_client(
         project=PROJECT, credentials=credentials, client_info=client_info
     )
-    data_client = client._data_client
+    data_client = client._veneer_data_client
 
     assert client._client_info is client_info
-    assert client._data_client is data_client
-    assert client._data_client.client_info is client_info
-    assert client._data_client._disable_background_channel_refresh
+    assert client._veneer_data_client is data_client
+    assert client._veneer_data_client.client_info is client_info
+    assert client._veneer_data_client._is_legacy_client
 
 
-def test_client_data_client_not_initialized_w_client_options():
+def test_client_veneer_data_client_not_initialized_w_client_options():
     from google.api_core.client_options import ClientOptions
 
     credentials = _make_credentials()
@@ -428,18 +428,18 @@ def test_client_data_client_not_initialized_w_client_options():
         project=PROJECT, credentials=credentials, client_options=client_options
     )
 
-    data_client = client._data_client
-    assert client._data_client is data_client
-    assert client._data_client._disable_background_channel_refresh
-    assert client._data_client._gapic_client._client_options == client_options
+    data_client = client._veneer_data_client
+    assert client._veneer_data_client is data_client
+    assert client._veneer_data_client._is_legacy_client
+    assert client._veneer_data_client._gapic_client._client_options == client_options
 
 
-def test_client_data_client_initialized():
+def test_client_veneer_data_client_initialized():
     credentials = _make_credentials()
     client = _make_client(project=PROJECT, credentials=credentials, admin=True)
 
     already = client._table_data_client = object()
-    assert client._data_client is already
+    assert client._veneer_data_client is already
 
 
 def test_client_data_gapic_client_not_initialized():