lint changes

Author: googlyrahman

google/cloud/storage/_experimental/asyncio/abstracts/async_connection.py

@@ -45,7 +45,7 @@ def __init__(self, client, client_info=None):
             )
         self._client_info.client_library_version = __version__
         self._extra_headers = {}
-    
+
     @property
     def extra_headers(self):
         """Returns extra headers to send with every request."""
@@ -71,4 +71,4 @@ def user_agent(self, value):
         self._client_info.user_agent = value
 
     async def close(self):
-        pass
+        pass

google/cloud/storage/_experimental/asyncio/async_client.py

@@ -16,7 +16,9 @@
 
 from google.cloud.storage._experimental.asyncio.async_creds import AsyncCredsWrapper
 from google.cloud.storage.abstracts.base_client import BaseClient
-from google.cloud.storage._experimental.asyncio.utility.async_json_connection import AsyncJSONConnection
+from google.cloud.storage._experimental.asyncio.utility.async_json_connection import (
+    AsyncJSONConnection,
+)
 from google.cloud.storage.abstracts import base_client
 
 _marker = base_client.marker
@@ -49,9 +51,11 @@ def __init__(
             client_info=client_info,
             client_options=client_options,
             extra_headers=extra_headers,
-            api_key=api_key
+            api_key=api_key,
         )
-        self.credentials = AsyncCredsWrapper(self._credentials) # self._credential is synchronous.
+        self.credentials = AsyncCredsWrapper(
+            self._credentials
+        )  # self._credential is synchronous.
         self._async_http = _async_http
 
         # We need both, as the same client can be used for multiple buckets.
@@ -65,13 +69,18 @@ def _grpc_connection(self):
     @property
     def _json_connection(self):
         if not self._json_connection_internal:
-            self._json_connection_internal = AsyncJSONConnection(self, _async_http=self._async_http, credentials=self.credentials, **self.connection_kw_args)
+            self._json_connection_internal = AsyncJSONConnection(
+                self,
+                _async_http=self._async_http,
+                credentials=self.credentials,
+                **self.connection_kw_args,
+            )
         return self._json_connection_internal
 
     async def close(self):
         if self._json_connection_internal:
             await self._json_connection_internal.close()
-        
+
         if self._grpc_connection_internal:
             await self._grpc_connection_internal.close()
 

google/cloud/storage/_experimental/asyncio/async_creds.py

@@ -5,21 +5,23 @@
 
 try:
     from google.auth.aio import credentials as aio_creds_module
+
     BaseCredentials = aio_creds_module.Credentials
     _AIO_AVAILABLE = True
 except ImportError:
     BaseCredentials = object
     _AIO_AVAILABLE = False
 
+
 class AsyncCredsWrapper(BaseCredentials):
     """Wraps synchronous Google Auth credentials to provide an asynchronous interface.
 
     Args:
-        sync_creds (google.auth.credentials.Credentials): The synchronous credentials 
+        sync_creds (google.auth.credentials.Credentials): The synchronous credentials
             instance to wrap.
 
     Raises:
-        ImportError: If instantiated in an environment where 'google.auth.aio' 
+        ImportError: If instantiated in an environment where 'google.auth.aio'
                      is not available.
     """
 
@@ -36,9 +38,7 @@ def __init__(self, sync_creds):
     async def refresh(self, request):
         """Refreshes the access token."""
         loop = asyncio.get_running_loop()
-        await loop.run_in_executor(
-            None, self.creds.refresh, Request()
-        )
+        await loop.run_in_executor(None, self.creds.refresh, Request())
 
     @property
     def valid(self):

google/cloud/storage/_experimental/asyncio/async_helpers.py

@@ -24,6 +24,7 @@ async def _do_nothing_page_start(iterator, page, response):
     # pylint: disable=unused-argument
     pass
 
+
 class AsyncHTTPIterator(AsyncIterator):
     """A generic class for iterating through HTTP/JSON API list responses asynchronously.
 
@@ -32,15 +33,15 @@ class AsyncHTTPIterator(AsyncIterator):
         api_request (Callable): The **async** function to use to make API requests.
             This must be an awaitable.
         path (str): The method path to query for the list of items.
-        item_to_value (Callable[AsyncIterator, Any]): Callable to convert an item 
+        item_to_value (Callable[AsyncIterator, Any]): Callable to convert an item
             from the type in the JSON response into a native object.
         items_key (str): The key in the API response where the list of items
             can be found.
         page_token (str): A token identifying a page in a result set.
         page_size (int): The maximum number of results to fetch per page.
         max_results (int): The maximum number of results to fetch.
         extra_params (dict): Extra query string parameters for the API call.
-        page_start (Callable): Callable to provide special behavior after a new page 
+        page_start (Callable): Callable to provide special behavior after a new page
             is created.
         next_token (str): The name of the field used in the response for page tokens.
     """
@@ -137,6 +138,4 @@ def _get_query_params(self):
     async def _get_next_page_response(self):
         """Requests the next page from the path provided asynchronously."""
         params = self._get_query_params()
-        return await self.api_request(
-            method="GET", path=self.path, query_params=params
-        )
+        return await self.api_request(method="GET", path=self.path, query_params=params)

google/cloud/storage/_experimental/asyncio/utility/async_json_connection.py

@@ -24,15 +24,19 @@
 from google.cloud.storage import _http as storage_http
 from google.cloud.storage import _helpers
 from google.cloud.storage._opentelemetry_tracing import create_trace_span
-from google.cloud.storage._experimental.asyncio.abstracts.async_connection import AsyncConnection
+from google.cloud.storage._experimental.asyncio.abstracts.async_connection import (
+    AsyncConnection,
+)
 
 try:
     from google.auth.aio.transport import sessions
+
     AsyncSession = sessions.AsyncAuthorizedSession
     _AIO_AVAILABLE = True
 except ImportError:
     _AIO_AVAILABLE = False
 
+
 class AsyncJSONConnection(AsyncConnection):
     """Implementation of Async JSON connection
 
@@ -42,7 +46,14 @@ class AsyncJSONConnection(AsyncConnection):
         api_endpoint: The API endpoint to use.
     """
 
-    def __init__(self, client, client_info=None, api_endpoint=None, _async_http=None, credentials=None):
+    def __init__(
+        self,
+        client,
+        client_info=None,
+        api_endpoint=None,
+        _async_http=None,
+        credentials=None,
+    ):
         if not _AIO_AVAILABLE:
             # Python 3.9 or less comes with an older version of google-auth library which doesn't support asyncio
             raise ImportError(
@@ -55,10 +66,10 @@ def __init__(self, client, client_info=None, api_endpoint=None, _async_http=None
         self.API_BASE_URL = api_endpoint or storage_http.Connection.DEFAULT_API_ENDPOINT
         self.API_VERSION = storage_http.Connection.API_VERSION
         self.API_URL_TEMPLATE = storage_http.Connection.API_URL_TEMPLATE
-        
+
         self.credentials = credentials
         self._async_http_internal = _async_http
-        self._async_http_passed_by_user = (_async_http is not None)
+        self._async_http_passed_by_user = _async_http is not None
 
     @property
     def async_http(self):
@@ -69,7 +80,10 @@ def async_http(self):
 
     async def close(self):
         """Close the session, if it exists"""
-        if self._async_http_internal is not None and not self._async_http_passed_by_user:
+        if (
+            self._async_http_internal is not None
+            and not self._async_http_passed_by_user
+        ):
             await self._async_http_internal.close()
 
     async def _make_request(

google/cloud/storage/_media/requests/download.py

@@ -774,6 +774,5 @@ def flush(self):
         def has_unconsumed_tail(self) -> bool:
             return self._decoder.has_unconsumed_tail
 
-
 else:  # pragma: NO COVER
     _BrotliDecoder = None  # type: ignore # pragma: NO COVER

google/cloud/storage/abstracts/base_client.py

@@ -30,6 +30,7 @@
 
 marker = object()
 
+
 class BaseClient(ClientWithProject, ABC):
     """Abstract class for python-storage Client"""
 
@@ -213,9 +214,7 @@ def _use_client_cert(self):
         if hasattr(mtls, "should_use_client_cert"):
             use_client_cert = mtls.should_use_client_cert()
         else:
-            use_client_cert = (
-                os.getenv("GOOGLE_API_USE_CLIENT_CERTIFICATE") == "true"
-            )
+            use_client_cert = os.getenv("GOOGLE_API_USE_CLIENT_CERTIFICATE") == "true"
         return use_client_cert
 
     @abstractmethod

google/cloud/storage/client.py

@@ -50,6 +50,7 @@
 
 _marker = base_client.marker
 
+
 def _buckets_page_start(iterator, page, response):
     """Grab unreachable buckets after a :class:`~google.cloud.iterator.Page` started."""
     unreachable = response.get("unreachable", [])
@@ -139,11 +140,13 @@ def __init__(
             client_options=client_options,
             use_auth_w_custom_endpoint=use_auth_w_custom_endpoint,
             extra_headers=extra_headers,
-            api_key=api_key
+            api_key=api_key,
         )
 
         # Pass extra_headers to Connection
-        connection = Connection(self, **self.connection_kw_args) # connection_kw_args would always be set in base class
+        connection = Connection(
+            self, **self.connection_kw_args
+        )  # connection_kw_args would always be set in base class
         connection.extra_headers = extra_headers
         self._connection = connection
 

tests/unit/asyncio/test_async_client.py

@@ -27,7 +27,7 @@ def _make_credentials():
 
 @pytest.mark.skipif(
     sys.version_info < (3, 10),
-    reason="Async Client requires Python 3.10+ due to google-auth-library asyncio support"
+    reason="Async Client requires Python 3.10+ due to google-auth-library asyncio support",
 )
 class TestAsyncClient:
     @staticmethod
@@ -42,43 +42,64 @@ def test_ctor_defaults(self):
         credentials = _make_credentials()
 
         # We mock AsyncJSONConnection to prevent network logic during init
-        with mock.patch("google.cloud.storage._experimental.asyncio.async_client.AsyncJSONConnection") as MockConn:
+        with mock.patch(
+            "google.cloud.storage._experimental.asyncio.async_client.AsyncJSONConnection"
+        ) as MockConn:
             client = self._make_one(project=PROJECT, credentials=credentials)
 
             assert client.project == PROJECT
 
             # It is the instance of the Mock
             assert isinstance(client._json_connection, mock.Mock)
             assert client._json_connection == MockConn.return_value
-            MockConn.assert_called_once_with(client, _async_http=None, credentials=client.credentials, client_info=None, api_endpoint=None)
+            MockConn.assert_called_once_with(
+                client,
+                _async_http=None,
+                credentials=client.credentials,
+                client_info=None,
+                api_endpoint=None,
+            )
 
     def test_ctor_mtls_raises_error(self):
         credentials = _make_credentials()
 
         # Simulate environment where mTLS is enabled
-        with mock.patch("google.cloud.storage.abstracts.base_client.BaseClient._use_client_cert", new_callable=mock.PropertyMock) as mock_mtls:
+        with mock.patch(
+            "google.cloud.storage.abstracts.base_client.BaseClient._use_client_cert",
+            new_callable=mock.PropertyMock,
+        ) as mock_mtls:
             mock_mtls.return_value = True
 
-            with pytest.raises(ValueError, match="Async Client currently do not support mTLS"):
+            with pytest.raises(
+                ValueError, match="Async Client currently do not support mTLS"
+            ):
                 self._make_one(credentials=credentials)
 
     def test_ctor_w_async_http_passed(self):
         credentials = _make_credentials()
         async_http = mock.Mock()
 
-        with mock.patch("google.cloud.storage._experimental.asyncio.async_client.AsyncJSONConnection") as MockConn:
+        with mock.patch(
+            "google.cloud.storage._experimental.asyncio.async_client.AsyncJSONConnection"
+        ) as MockConn:
             client = self._make_one(
-                project="PROJECT",
-                credentials=credentials,
-                _async_http=async_http
+                project="PROJECT", credentials=credentials, _async_http=async_http
             )
 
             client._json_connection
-            MockConn.assert_called_once_with(client, _async_http=async_http, credentials=client.credentials, client_info=None, api_endpoint=None)
+            MockConn.assert_called_once_with(
+                client,
+                _async_http=async_http,
+                credentials=client.credentials,
+                client_info=None,
+                api_endpoint=None,
+            )
 
     def test_bucket_not_implemented(self):
         credentials = _make_credentials()
-        with mock.patch("google.cloud.storage._experimental.asyncio.async_client.AsyncJSONConnection"):
+        with mock.patch(
+            "google.cloud.storage._experimental.asyncio.async_client.AsyncJSONConnection"
+        ):
             client = self._make_one(project="PROJECT", credentials=credentials)
 
         with pytest.raises(NotImplementedError):