renamed replaceablechannel to swappablechannel

Author: daniel-sanche

…able/data/_async/_replaceable_channel.py …gtable/data/_async/_swappable_channel.pygoogle/cloud/bigtable/data/_async/_replaceable_channel.py renamed to google/cloud/bigtable/data/_async/_swappable_channel.py google/cloud/bigtable/data/_async/_replaceable_channel.py renamed to google/cloud/bigtable/data/_async/_swappable_channel.py

@@ -25,7 +25,7 @@
 else:
     from grpc import Channel
 
-__CROSS_SYNC_OUTPUT__ = "google.cloud.bigtable.data._sync_autogen._replaceable_channel"
+__CROSS_SYNC_OUTPUT__ = "google.cloud.bigtable.data._sync_autogen._swappable_channel"
 
 
 @CrossSync.convert_class(sync_name="_WrappedChannel", rm_aio=True)
@@ -91,10 +91,10 @@ def unsubscribe(self, callback):
 
 
 @CrossSync.convert_class(
-    sync_name="_ReplaceableChannel",
+    sync_name="SwappableChannel",
     replace_symbols={"_AsyncWrappedChannel": "_WrappedChannel"},
 )
-class _AsyncReplaceableChannel(_AsyncWrappedChannel):
+class AsyncSwappableChannel(_AsyncWrappedChannel):
     def __init__(self, channel_fn: Callable[[], Channel]):
         self._channel_fn = channel_fn
         self._channel = channel_fn()
@@ -119,7 +119,7 @@ def create_channel(self) -> Channel:
             )
         return new_channel
 
-    def replace_wrapped_channel(self, new_channel: Channel) -> Channel:
+    def swap_channel(self, new_channel: Channel) -> Channel:
         old_channel = self._channel
         self._channel = new_channel
         return old_channel

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

@@ -96,17 +96,17 @@
         BigtableAsyncClient as GapicClient,
     )
     from google.cloud.bigtable.data._async.mutations_batcher import _MB_SIZE
-    from google.cloud.bigtable.data._async._replaceable_channel import (
-        _AsyncReplaceableChannel,
+    from google.cloud.bigtable.data._async._swappable_channel import (
+        AsyncSwappableChannel,
     )
 else:
     from typing import Iterable  # noqa: F401
     from grpc import insecure_channel
     from google.cloud.bigtable_v2.services.bigtable.transports import BigtableGrpcTransport as TransportType  # type: ignore
     from google.cloud.bigtable_v2.services.bigtable import BigtableClient as GapicClient  # type: ignore
     from google.cloud.bigtable.data._sync_autogen.mutations_batcher import _MB_SIZE
-    from google.cloud.bigtable.data._sync_autogen._replaceable_channel import (  # noqa: F401
-        _ReplaceableChannel,
+    from google.cloud.bigtable.data._sync_autogen._swappable_channel import (  # noqa: F401
+        SwappableChannel,
     )
 
 
@@ -244,15 +244,15 @@ def __init__(
                 )
 
     @CrossSync.convert(
-        replace_symbols={"_AsyncReplaceableChannel": "_ReplaceableChannel"}
+        replace_symbols={"AsyncSwappableChannel": "SwappableChannel"}
     )
-    def _build_grpc_channel(self, *args, **kwargs) -> _AsyncReplaceableChannel:
+    def _build_grpc_channel(self, *args, **kwargs) -> AsyncSwappableChannel:
         if self._emulator_host is not None:
             # emulators use insecure channel
             create_channel_fn = partial(insecure_channel, self._emulator_host)
         else:
             create_channel_fn = partial(TransportType.create_channel, *args, **kwargs)
-        return _AsyncReplaceableChannel(create_channel_fn)
+        return AsyncSwappableChannel(create_channel_fn)
 
     @staticmethod
     def _client_version() -> str:
@@ -357,7 +357,7 @@ def _invalidate_channel_stubs(self):
         self.transport._prep_wrapped_messages(self.client_info)
 
     @CrossSync.convert(
-        replace_symbols={"_AsyncReplaceableChannel": "_ReplaceableChannel"}
+        replace_symbols={"AsyncSwappableChannel": "SwappableChannel"}
     )
     async def _manage_channel(
         self,
@@ -383,10 +383,10 @@ async def _manage_channel(
             grace_period: time to allow previous channel to serve existing
                 requests before closing, in seconds
         """
-        if not isinstance(self.transport.grpc_channel, _AsyncReplaceableChannel):
+        if not isinstance(self.transport.grpc_channel, AsyncSwappableChannel):
             warnings.warn("Channel does not support auto-refresh.")
             return
-        super_channel: _AsyncReplaceableChannel = self.transport.grpc_channel
+        super_channel: AsyncSwappableChannel = self.transport.grpc_channel
         first_refresh = self._channel_init_time + random.uniform(
             refresh_interval_min, refresh_interval_max
         )
@@ -409,7 +409,7 @@ async def _manage_channel(
             new_channel = super_channel.create_channel()
             await self._ping_and_warm_instances(channel=new_channel)
             # cycle channel out of use, with long grace window before closure
-            old_channel = super_channel.replace_wrapped_channel(new_channel)
+            old_channel = super_channel.swap_channel(new_channel)
             self._invalidate_channel_stubs()
             # give old_channel a chance to complete existing rpcs
             if CrossSync.is_async:

…ta/_sync_autogen/_replaceable_channel.py …data/_sync_autogen/_swappable_channel.pygoogle/cloud/bigtable/data/_sync_autogen/_replaceable_channel.py renamed to google/cloud/bigtable/data/_sync_autogen/_swappable_channel.py google/cloud/bigtable/data/_sync_autogen/_replaceable_channel.py renamed to google/cloud/bigtable/data/_sync_autogen/_swappable_channel.py

@@ -71,7 +71,7 @@ def unsubscribe(self, callback):
         return self._channel.unsubscribe(callback)
 
 
-class _ReplaceableChannel(_WrappedChannel):
+class SwappableChannel(_WrappedChannel):
     def __init__(self, channel_fn: Callable[[], Channel]):
         self._channel_fn = channel_fn
         self._channel = channel_fn()
@@ -80,7 +80,7 @@ def create_channel(self) -> Channel:
         new_channel = self._channel_fn()
         return new_channel
 
-    def replace_wrapped_channel(self, new_channel: Channel) -> Channel:
+    def swap_channel(self, new_channel: Channel) -> Channel:
         old_channel = self._channel
         self._channel = new_channel
         return old_channel

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

@@ -80,9 +80,7 @@
 )
 from google.cloud.bigtable_v2.services.bigtable import BigtableClient as GapicClient
 from google.cloud.bigtable.data._sync_autogen.mutations_batcher import _MB_SIZE
-from google.cloud.bigtable.data._sync_autogen._replaceable_channel import (
-    _ReplaceableChannel,
-)
+from google.cloud.bigtable.data._sync_autogen._swappable_channel import SwappableChannel
 
 if TYPE_CHECKING:
     from google.cloud.bigtable.data._helpers import RowKeySamples
@@ -180,12 +178,12 @@ def __init__(
                     stacklevel=2,
                 )
 
-    def _build_grpc_channel(self, *args, **kwargs) -> _ReplaceableChannel:
+    def _build_grpc_channel(self, *args, **kwargs) -> SwappableChannel:
         if self._emulator_host is not None:
             create_channel_fn = partial(insecure_channel, self._emulator_host)
         else:
             create_channel_fn = partial(TransportType.create_channel, *args, **kwargs)
-        return _ReplaceableChannel(create_channel_fn)
+        return SwappableChannel(create_channel_fn)
 
     @staticmethod
     def _client_version() -> str:
@@ -290,10 +288,10 @@ def _manage_channel(
                 between `refresh_interval_min` and `refresh_interval_max`
             grace_period: time to allow previous channel to serve existing
                 requests before closing, in seconds"""
-        if not isinstance(self.transport.grpc_channel, _ReplaceableChannel):
+        if not isinstance(self.transport.grpc_channel, SwappableChannel):
             warnings.warn("Channel does not support auto-refresh.")
             return
-        super_channel: _ReplaceableChannel = self.transport.grpc_channel
+        super_channel: SwappableChannel = self.transport.grpc_channel
         first_refresh = self._channel_init_time + random.uniform(
             refresh_interval_min, refresh_interval_max
         )
@@ -309,7 +307,7 @@ def _manage_channel(
             start_timestamp = time.monotonic()
             new_channel = super_channel.create_channel()
             self._ping_and_warm_instances(channel=new_channel)
-            old_channel = super_channel.replace_wrapped_channel(new_channel)
+            old_channel = super_channel.swap_channel(new_channel)
             self._invalidate_channel_stubs()
             if grace_period:
                 self._is_closed.wait(grace_period)

tests/unit/data/_async/test_client.py

@@ -51,21 +51,21 @@
 if CrossSync.is_async:
     from google.api_core import grpc_helpers_async
     from google.cloud.bigtable.data._async.client import TableAsync
-    from google.cloud.bigtable.data._async._replaceable_channel import (
-        _AsyncReplaceableChannel,
+    from google.cloud.bigtable.data._async._swappable_channel import (
+        AsyncSwappableChannel,
     )
 
     CrossSync.add_mapping("grpc_helpers", grpc_helpers_async)
-    CrossSync.add_mapping("ReplaceableChannel", _AsyncReplaceableChannel)
+    CrossSync.add_mapping("SwappableChannel", AsyncSwappableChannel)
 else:
     from google.api_core import grpc_helpers
     from google.cloud.bigtable.data._sync_autogen.client import Table  # noqa: F401
-    from google.cloud.bigtable.data._sync_autogen._replaceable_channel import (
-        _ReplaceableChannel,
+    from google.cloud.bigtable.data._sync_autogen._swappable_channel import (
+        SwappableChannel,
     )
 
     CrossSync.add_mapping("grpc_helpers", grpc_helpers)
-    CrossSync.add_mapping("ReplaceableChannel", _ReplaceableChannel)
+    CrossSync.add_mapping("SwappableChannel", SwappableChannel)
 
 __CROSS_SYNC_OUTPUT__ = "tests.unit.data._sync_autogen.test_client"
 
@@ -236,7 +236,7 @@ async def test__start_background_channel_refresh(self):
             client, "_ping_and_warm_instances", CrossSync.Mock()
         ) as ping_and_warm:
             client._emulator_host = None
-            client.transport._grpc_channel = CrossSync.ReplaceableChannel(mock.Mock)
+            client.transport._grpc_channel = CrossSync.SwappableChannel(mock.Mock)
             client._start_background_channel_refresh()
             assert client._channel_refresh_task is not None
             assert isinstance(client._channel_refresh_task, CrossSync.Task)
@@ -500,7 +500,7 @@ async def test__manage_channel_refresh(self, num_cycles):
         new_channel = grpc_lib.insecure_channel("localhost:8080")
         create_channel_mock = mock.Mock()
         create_channel_mock.return_value = new_channel
-        refreshable_channel = CrossSync.ReplaceableChannel(create_channel_mock)
+        refreshable_channel = CrossSync.SwappableChannel(create_channel_mock)
 
         with mock.patch.object(CrossSync, "event_wait") as sleep:
             sleep.side_effect = [None for i in range(num_cycles)] + [RuntimeError]

tests/unit/data/_sync_autogen/test_client.py

@@ -45,12 +45,10 @@
     str_val,
 )
 from google.api_core import grpc_helpers
-from google.cloud.bigtable.data._sync_autogen._replaceable_channel import (
-    _ReplaceableChannel,
-)
+from google.cloud.bigtable.data._sync_autogen._swappable_channel import SwappableChannel
 
 CrossSync._Sync_Impl.add_mapping("grpc_helpers", grpc_helpers)
-CrossSync._Sync_Impl.add_mapping("ReplaceableChannel", _ReplaceableChannel)
+CrossSync._Sync_Impl.add_mapping("SwappableChannel", SwappableChannel)
 
 
 @CrossSync._Sync_Impl.add_mapping_decorator("TestBigtableDataClient")
@@ -185,7 +183,7 @@ def test__start_background_channel_refresh(self):
             client, "_ping_and_warm_instances", CrossSync._Sync_Impl.Mock()
         ) as ping_and_warm:
             client._emulator_host = None
-            client.transport._grpc_channel = CrossSync._Sync_Impl.ReplaceableChannel(
+            client.transport._grpc_channel = CrossSync._Sync_Impl.SwappableChannel(
                 mock.Mock
             )
             client._start_background_channel_refresh()
@@ -398,9 +396,7 @@ def test__manage_channel_refresh(self, num_cycles):
         new_channel = grpc_lib.insecure_channel("localhost:8080")
         create_channel_mock = mock.Mock()
         create_channel_mock.return_value = new_channel
-        refreshable_channel = CrossSync._Sync_Impl.ReplaceableChannel(
-            create_channel_mock
-        )
+        refreshable_channel = CrossSync._Sync_Impl.SwappableChannel(create_channel_mock)
         with mock.patch.object(CrossSync._Sync_Impl, "event_wait") as sleep:
             sleep.side_effect = [None for i in range(num_cycles)] + [RuntimeError]
             client = self._make_client(project="project-id")