fix linting

Author: chandra-siri

google/api_core/bidi_async.py

@@ -25,48 +25,48 @@
 class _AsyncRequestQueueGenerator:
     """An async helper for sending requests to a gRPC stream from a Queue.
 
-    This generator takes requests off a given queue and yields them to gRPC.
-
-    This helper is useful when you have an indeterminate, indefinite, or
-    otherwise open-ended set of requests to send through a request-streaming
-    (or bidirectional) RPC.
-
-    The reason this is necessary is because gRPC takes an async iterator as the
-    request for request-streaming RPCs. gRPC consumes this iterator to allow
-    it to block while generating requests for the stream. However, if the
-    generator blocks indefinitely gRPC will not be able to clean up the task
-    as it'll be blocked on `anext(iterator)` and not be able to check the
-    channel status to stop iterating. This helper mitigates that by waiting
-    on the queue with a timeout and checking the RPC state before yielding.
-
-    Finally, it allows for retrying without swapping queues because if it does
-    pull an item off the queue when the RPC is inactive, it'll immediately put
-    it back and then exit. This is necessary because yielding the item in this
-    case will cause gRPC to discard it. In practice, this means that the order
-of messages is not guaranteed. If such a thing is necessary it would be
-    easy to use a priority queue.
+        This generator takes requests off a given queue and yields them to gRPC.
 
-    Example::
+        This helper is useful when you have an indeterminate, indefinite, or
+        otherwise open-ended set of requests to send through a request-streaming
+        (or bidirectional) RPC.
 
-        requests = _AsyncRequestQueueGenerator(q)
-        call = await stub.StreamingRequest(requests)
-        requests.call = call
+        The reason this is necessary is because gRPC takes an async iterator as the
+        request for request-streaming RPCs. gRPC consumes this iterator to allow
+        it to block while generating requests for the stream. However, if the
+        generator blocks indefinitely gRPC will not be able to clean up the task
+        as it'll be blocked on `anext(iterator)` and not be able to check the
+        channel status to stop iterating. This helper mitigates that by waiting
+        on the queue with a timeout and checking the RPC state before yielding.
 
-        async for response in call:
-            print(response)
-            await q.put(...)
+        Finally, it allows for retrying without swapping queues because if it does
+        pull an item off the queue when the RPC is inactive, it'll immediately put
+        it back and then exit. This is necessary because yielding the item in this
+        case will cause gRPC to discard it. In practice, this means that the order
+    of messages is not guaranteed. If such a thing is necessary it would be
+        easy to use a priority queue.
 
-    Args:
-        queue (asyncio.Queue): The request queue.
-        period (float): The number of seconds to wait for items from the queue
-            before checking if the RPC is cancelled. In practice, this
-            determines the maximum amount of time the request consumption
-            task will live after the RPC is cancelled.
-        initial_request (Union[protobuf.Message,
-                Callable[[], protobuf.Message]]): The initial request to
-            yield. This is done independently of the request queue to allow for
-            easily restarting streams that require some initial configuration
-            request.
+        Example::
+
+            requests = _AsyncRequestQueueGenerator(q)
+            call = await stub.StreamingRequest(requests)
+            requests.call = call
+
+            async for response in call:
+                print(response)
+                await q.put(...)
+
+        Args:
+            queue (asyncio.Queue): The request queue.
+            period (float): The number of seconds to wait for items from the queue
+                before checking if the RPC is cancelled. In practice, this
+                determines the maximum amount of time the request consumption
+                task will live after the RPC is cancelled.
+            initial_request (Union[protobuf.Message,
+                    Callable[[], protobuf.Message]]): The initial request to
+                yield. This is done independently of the request queue to allow for
+                easily restarting streams that require some initial configuration
+                request.
     """
 
     def __init__(self, queue: asyncio.Queue, period: float = 1, initial_request=None):
@@ -122,7 +122,6 @@ async def __aiter__(self):
             yield item
 
 
-
 class AsyncBidiRpc:
     """A helper for consuming a async bi-directional streaming RPC.
 

tests/asyncio/test_bidi_async.py

@@ -22,13 +22,11 @@
 import pytest
 
 try:
-    import grpc
     from grpc import aio
 except ImportError:  # pragma: NO COVER
     pytest.skip("No GRPC", allow_module_level=True)
 
 from google.api_core import bidi_async
-from google.api_core import exceptions
 
 
 async def consume_async_generator(gen):