fixed lint

Author: daniel-sanche

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

@@ -27,6 +27,7 @@
 
 __CROSS_SYNC_OUTPUT__ = "google.cloud.bigtable.data._sync_autogen._replaceable_channel"
 
+
 @CrossSync.convert_class(sync_name="_WrappedChannel", rm_aio=True)
 class _AsyncWrappedChannel(Channel):
     """
@@ -49,15 +50,12 @@ def stream_unary(self, *args, **kwargs):
     def stream_stream(self, *args, **kwargs):
         return self._channel.stream_stream(*args, **kwargs)
 
-    # grace not supported by sync version
-    @CrossSync.drop
-    async def close(self, grace=None):
-        return await self._channel.close(grace=grace)
-
     async def channel_ready(self):
         return await self._channel.channel_ready()
 
-    @CrossSync.convert(sync_name="__enter__", replace_symbols={"__aenter__": "__enter__"})
+    @CrossSync.convert(
+        sync_name="__enter__", replace_symbols={"__aenter__": "__enter__"}
+    )
     async def __aenter__(self):
         await self._channel.__aenter__()
         return self
@@ -75,7 +73,13 @@ async def wait_for_state_change(self, last_observed_state):
     def __getattr__(self, name):
         return getattr(self._channel, name)
 
-    if not CrossSync.is_async:
+    if CrossSync.is_async:
+        # grace not supported by sync version
+        async def close(self, grace=None):
+            return await self._channel.close(grace=grace)
+
+    else:
+        # add required sync methods
 
         def close(self):
             return self._channel.close()
@@ -87,9 +91,11 @@ def unsubscribe(self, callback):
             return self._channel.unsubscribe(callback)
 
 
-@CrossSync.convert_class(sync_name="_ReplaceableChannel", replace_symbols={"_AsyncWrappedChannel": "_WrappedChannel"})
+@CrossSync.convert_class(
+    sync_name="_ReplaceableChannel",
+    replace_symbols={"_AsyncWrappedChannel": "_WrappedChannel"},
+)
 class _AsyncReplaceableChannel(_AsyncWrappedChannel):
-
     def __init__(self, channel_fn: Callable[[], Channel]):
         self._channel_fn = channel_fn
         self._channel = channel_fn()
@@ -100,13 +106,21 @@ def create_channel(self) -> Channel:
             # copy over interceptors
             # this is needed because of how gapic attaches the LoggingClientAIOInterceptor
             # sync channels add interceptors by wrapping, so this step isn't needed
-            new_channel._unary_unary_interceptors = self._channel._unary_unary_interceptors
-            new_channel._unary_stream_interceptors = self._channel._unary_stream_interceptors
-            new_channel._stream_unary_interceptors = self._channel._stream_unary_interceptors
-            new_channel._stream_stream_interceptors = self._channel._stream_stream_interceptors
+            new_channel._unary_unary_interceptors = (
+                self._channel._unary_unary_interceptors
+            )
+            new_channel._unary_stream_interceptors = (
+                self._channel._unary_stream_interceptors
+            )
+            new_channel._stream_unary_interceptors = (
+                self._channel._stream_unary_interceptors
+            )
+            new_channel._stream_stream_interceptors = (
+                self._channel._stream_stream_interceptors
+            )
         return new_channel
 
     def replace_wrapped_channel(self, new_channel: Channel) -> Channel:
         old_channel = self._channel
         self._channel = new_channel
-        return old_channel
+        return old_channel

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

@@ -92,18 +92,18 @@
     from google.cloud.bigtable_v2.services.bigtable.transports import (
         BigtableGrpcAsyncIOTransport as TransportType,
     )
-    from google.cloud.bigtable_v2.services.bigtable.transports.grpc_asyncio import (
-        _LoggingClientAIOInterceptor
-    )
     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._replaceable_channel import (
+        _AsyncReplaceableChannel,
+    )
 else:
     from typing import Iterable  # noqa: F401
     from grpc import insecure_channel
-    from grpc import intercept_channel
     from google.cloud.bigtable_v2.services.bigtable.transports import BigtableGrpcTransport as TransportType  # type: ignore
     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._replaceable_channel import (  # noqa: F401
+        _ReplaceableChannel,
+    )
 
 
 if TYPE_CHECKING:
@@ -239,7 +239,9 @@ def __init__(
                     stacklevel=2,
                 )
 
-    @CrossSync.convert(replace_symbols={"_AsyncReplaceableChannel": "_ReplaceableChannel"})
+    @CrossSync.convert(
+        replace_symbols={"_AsyncReplaceableChannel": "_ReplaceableChannel"}
+    )
     def _build_grpc_channel(self, *args, **kwargs) -> _AsyncReplaceableChannel:
         if self._emulator_host is not None:
             # emulators use insecure channel
@@ -248,7 +250,6 @@ def _build_grpc_channel(self, *args, **kwargs) -> _AsyncReplaceableChannel:
             create_channel_fn = partial(TransportType.create_channel, *args, **kwargs)
         return _AsyncReplaceableChannel(create_channel_fn)
 
-
     @staticmethod
     def _client_version() -> str:
         """
@@ -351,7 +352,9 @@ def _invalidate_channel_stubs(self):
         self.transport._stubs = {}
         self.transport._prep_wrapped_messages(self.client_info)
 
-    @CrossSync.convert(replace_symbols={"_AsyncReplaceableChannel": "_ReplaceableChannel"})
+    @CrossSync.convert(
+        replace_symbols={"_AsyncReplaceableChannel": "_ReplaceableChannel"}
+    )
     async def _manage_channel(
         self,
         refresh_interval_min: float = 60 * 35,

tests/unit/data/_async/test_client.py

@@ -51,14 +51,18 @@
 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._replaceable_channel import (
+        _AsyncReplaceableChannel,
+    )
 
     CrossSync.add_mapping("grpc_helpers", grpc_helpers_async)
     CrossSync.add_mapping("ReplaceableChannel", _AsyncReplaceableChannel)
 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._replaceable_channel import (
+        _ReplaceableChannel,
+    )
 
     CrossSync.add_mapping("grpc_helpers", grpc_helpers)
     CrossSync.add_mapping("ReplaceableChannel", _ReplaceableChannel)
@@ -388,18 +392,8 @@ async def test__manage_channel_ping_and_warm(self):
         """
         _manage channel should call ping and warm internally
         """
-        import time
         import threading
 
-        if CrossSync.is_async:
-            from google.cloud.bigtable_v2.services.bigtable.transports.grpc_asyncio import (
-                _LoggingClientAIOInterceptor as Interceptor,
-            )
-        else:
-            from google.cloud.bigtable_v2.services.bigtable.transports.grpc import (
-                _LoggingClientInterceptor as Interceptor,
-            )
-
         client = self._make_client(project="project-id", use_emulator=True)
         orig_channel = client.transport.grpc_channel
         # should ping an warm all new channels, and old channels if sleeping