azure-storage-blob 12.25.0b1__py3-none-any.whl → 12.26.0__py3-none-any.whl

azure/storage/blob/_shared/base_client.py

@@ -20,7 +20,10 @@ from urllib.parse import parse_qs, quote
 from azure.core.credentials import AzureSasCredential, AzureNamedKeyCredential, TokenCredential
 from azure.core.exceptions import HttpResponseError
 from azure.core.pipeline import Pipeline
-from azure.core.pipeline.transport import HttpTransport, RequestsTransport  # pylint: disable=non-abstract-transport-import, no-name-in-module
+from azure.core.pipeline.transport import (  # pylint: disable=non-abstract-transport-import, no-name-in-module
+    HttpTransport,
+    RequestsTransport,
+)
 from azure.core.pipeline.policies import (
     AzureSasCredentialPolicy,
     ContentDecodePolicy,
@@ -65,27 +68,42 @@ _SERVICE_PARAMS = {
 
 
 class StorageAccountHostsMixin(object):
+
     _client: Any
+    _hosts: Dict[str, str]
+
     def __init__(
         self,
         parsed_url: Any,
         service: str,
-        credential: Optional[Union[str, Dict[str, str], AzureNamedKeyCredential, AzureSasCredential, "AsyncTokenCredential", TokenCredential]] = None,  # pylint: disable=line-too-long
-        **kwargs: Any
+        credential: Optional[
+            Union[
+                str,
+                Dict[str, str],
+                AzureNamedKeyCredential,
+                AzureSasCredential,
+                "AsyncTokenCredential",
+                TokenCredential,
+            ]
+        ] = None,
+        **kwargs: Any,
     ) -> None:
         self._location_mode = kwargs.get("_location_mode", LocationMode.PRIMARY)
-        self._hosts = kwargs.get("_hosts")
+        self._hosts = kwargs.get("_hosts", {})
         self.scheme = parsed_url.scheme
         self._is_localhost = False
 
         if service not in ["blob", "queue", "file-share", "dfs"]:
             raise ValueError(f"Invalid service: {service}")
-        service_name = service.split('-')[0]
+        service_name = service.split("-")[0]
         account = parsed_url.netloc.split(f".{service_name}.core.")
 
         self.account_name = account[0] if len(account) > 1 else None
-        if not self.account_name and parsed_url.netloc.startswith("localhost") \
-                or parsed_url.netloc.startswith("127.0.0.1"):
+        if (
+            not self.account_name
+            and parsed_url.netloc.startswith("localhost")
+            or parsed_url.netloc.startswith("127.0.0.1")
+        ):
             self._is_localhost = True
             self.account_name = parsed_url.path.strip("/")
 
@@ -93,7 +111,7 @@ class StorageAccountHostsMixin(object):
         if self.scheme.lower() != "https" and hasattr(self.credential, "get_token"):
             raise ValueError("Token credential is only supported with HTTPS.")
 
-        secondary_hostname = None
+        secondary_hostname = ""
         if hasattr(self.credential, "account_name"):
             self.account_name = self.credential.account_name
             secondary_hostname = f"{self.credential.account_name}-secondary.{service_name}.{SERVICE_HOST_BASE}"
@@ -103,7 +121,7 @@ class StorageAccountHostsMixin(object):
                 secondary_hostname = parsed_url.netloc.replace(account[0], account[0] + "-secondary")
             if kwargs.get("secondary_hostname"):
                 secondary_hostname = kwargs["secondary_hostname"]
-            primary_hostname = (parsed_url.netloc + parsed_url.path).rstrip('/')
+            primary_hostname = (parsed_url.netloc + parsed_url.path).rstrip("/")
             self._hosts = {LocationMode.PRIMARY: primary_hostname, LocationMode.SECONDARY: secondary_hostname}
 
         self._sdk_moniker = f"storage-{service}/{VERSION}"
@@ -116,70 +134,76 @@ class StorageAccountHostsMixin(object):
     def __exit__(self, *args):
         self._client.__exit__(*args)
 
-    def close(self):
-        """ This method is to close the sockets opened by the client.
+    def close(self) -> None:
+        """This method is to close the sockets opened by the client.
         It need not be used when using with a context manager.
         """
         self._client.close()
 
     @property
-    def url(self):
+    def url(self) -> str:
         """The full endpoint URL to this entity, including SAS token if used.
 
         This could be either the primary endpoint,
         or the secondary endpoint depending on the current :func:`location_mode`.
-        :returns: The full endpoint URL to this entity, including SAS token if used.
+
+        :return: The full endpoint URL to this entity, including SAS token if used.
         :rtype: str
         """
-        return self._format_url(self._hosts[self._location_mode])
+        return self._format_url(self._hosts[self._location_mode])   # type: ignore
 
     @property
-    def primary_endpoint(self):
+    def primary_endpoint(self) -> str:
         """The full primary endpoint URL.
 
+        :return: The full primary endpoint URL.
         :rtype: str
         """
-        return self._format_url(self._hosts[LocationMode.PRIMARY])
+        return self._format_url(self._hosts[LocationMode.PRIMARY])  # type: ignore
 
     @property
-    def primary_hostname(self):
+    def primary_hostname(self) -> str:
         """The hostname of the primary endpoint.
 
+        :return: The hostname of the primary endpoint.
         :rtype: str
         """
         return self._hosts[LocationMode.PRIMARY]
 
     @property
-    def secondary_endpoint(self):
+    def secondary_endpoint(self) -> str:
         """The full secondary endpoint URL if configured.
 
         If not available a ValueError will be raised. To explicitly specify a secondary hostname, use the optional
         `secondary_hostname` keyword argument on instantiation.
 
+        :return: The full secondary endpoint URL.
         :rtype: str
-        :raise ValueError:
+        :raise ValueError: If no secondary endpoint is configured.
         """
         if not self._hosts[LocationMode.SECONDARY]:
             raise ValueError("No secondary host configured.")
-        return self._format_url(self._hosts[LocationMode.SECONDARY])
+        return self._format_url(self._hosts[LocationMode.SECONDARY])    # type: ignore
 
     @property
-    def secondary_hostname(self):
+    def secondary_hostname(self) -> Optional[str]:
         """The hostname of the secondary endpoint.
 
         If not available this will be None. To explicitly specify a secondary hostname, use the optional
         `secondary_hostname` keyword argument on instantiation.
 
+        :return: The hostname of the secondary endpoint, or None if not configured.
         :rtype: Optional[str]
         """
         return self._hosts[LocationMode.SECONDARY]
 
     @property
-    def location_mode(self):
+    def location_mode(self) -> str:
         """The location mode that the client is currently using.
 
         By default this will be "primary". Options include "primary" and "secondary".
 
+        :return: The current location mode.
         :rtype: str
         """
 
@@ -202,11 +226,16 @@ class StorageAccountHostsMixin(object):
         return self._client._config.version  # pylint: disable=protected-access
 
     def _format_query_string(
-        self, sas_token: Optional[str],
-        credential: Optional[Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", TokenCredential]],  # pylint: disable=line-too-long
+        self,
+        sas_token: Optional[str],
+        credential: Optional[
+            Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", TokenCredential]
+        ],
         snapshot: Optional[str] = None,
-        share_snapshot: Optional[str] = None
-    ) -> Tuple[str, Optional[Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", TokenCredential]]]:  # pylint: disable=line-too-long
+        share_snapshot: Optional[str] = None,
+    ) -> Tuple[
+        str, Optional[Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", TokenCredential]]
+    ]:
         query_str = "?"
         if snapshot:
             query_str += f"snapshot={snapshot}&"
@@ -214,7 +243,8 @@ class StorageAccountHostsMixin(object):
             query_str += f"sharesnapshot={share_snapshot}&"
         if sas_token and isinstance(credential, AzureSasCredential):
             raise ValueError(
-                "You cannot use AzureSasCredential when the resource URI also contains a Shared Access Signature.")
+                "You cannot use AzureSasCredential when the resource URI also contains a Shared Access Signature."
+            )
         if _is_credential_sastoken(credential):
             credential = cast(str, credential)
             query_str += credential.lstrip("?")
@@ -224,13 +254,16 @@ class StorageAccountHostsMixin(object):
         return query_str.rstrip("?&"), credential
 
     def _create_pipeline(
-        self, credential: Optional[Union[str, Dict[str, str], AzureNamedKeyCredential, AzureSasCredential, TokenCredential]] = None,  # pylint: disable=line-too-long
-        **kwargs: Any
+        self,
+        credential: Optional[
+            Union[str, Dict[str, str], AzureNamedKeyCredential, AzureSasCredential, TokenCredential]
+        ] = None,
+        **kwargs: Any,
     ) -> Tuple[StorageConfiguration, Pipeline]:
         self._credential_policy: Any = None
         if hasattr(credential, "get_token"):
-            if kwargs.get('audience'):
-                audience = str(kwargs.pop('audience')).rstrip('/') + DEFAULT_OAUTH_SCOPE
+            if kwargs.get("audience"):
+                audience = str(kwargs.pop("audience")).rstrip("/") + DEFAULT_OAUTH_SCOPE
             else:
                 audience = STORAGE_OAUTH_SCOPE
             self._credential_policy = StorageBearerTokenCredentialPolicy(cast(TokenCredential, credential), audience)
@@ -264,22 +297,18 @@ class StorageAccountHostsMixin(object):
             config.logging_policy,
             StorageResponseHook(**kwargs),
             DistributedTracingPolicy(**kwargs),
-            HttpLoggingPolicy(**kwargs)
+            HttpLoggingPolicy(**kwargs),
         ]
         if kwargs.get("_additional_pipeline_policies"):
             policies = policies + kwargs.get("_additional_pipeline_policies")  # type: ignore
         config.transport = transport  # type: ignore
         return config, Pipeline(transport, policies=policies)
 
-    def _batch_send(
-        self,
-        *reqs: "HttpRequest",
-        **kwargs: Any
-    ) -> Iterator["HttpResponse"]:
+    def _batch_send(self, *reqs: "HttpRequest", **kwargs: Any) -> Iterator["HttpResponse"]:
         """Given a series of request, do a Storage batch call.
 
         :param HttpRequest reqs: A collection of HttpRequest objects.
-        :returns: An iterator of HttpResponse objects.
+        :return: An iterator of HttpResponse objects.
         :rtype: Iterator[HttpResponse]
         """
         # Pop it here, so requests doesn't feel bad about additional kwarg
@@ -288,25 +317,21 @@ class StorageAccountHostsMixin(object):
 
         request = self._client._client.post(  # pylint: disable=protected-access
             url=(
-                f'{self.scheme}://{self.primary_hostname}/'
+                f"{self.scheme}://{self.primary_hostname}/"
                 f"{kwargs.pop('path', '')}?{kwargs.pop('restype', '')}"
                 f"comp=batch{kwargs.pop('sas', '')}{kwargs.pop('timeout', '')}"
             ),
             headers={
-                'x-ms-version': self.api_version,
-                "Content-Type": "multipart/mixed; boundary=" + _get_batch_request_delimiter(batch_id, False, False)
-            }
+                "x-ms-version": self.api_version,
+                "Content-Type": "multipart/mixed; boundary=" + _get_batch_request_delimiter(batch_id, False, False),
+            },
         )
 
         policies = [StorageHeadersPolicy()]
         if self._credential_policy:
             policies.append(self._credential_policy)
 
-        request.set_multipart_mixed(
-            *reqs,
-            policies=policies,
-            enforce_https=False
-        )
+        request.set_multipart_mixed(*reqs, policies=policies, enforce_https=False)
 
         Pipeline._prepare_multipart_mixed_request(request)  # pylint: disable=protected-access
         body = serialize_batch_body(request.multipart_mixed_info[0], batch_id)
@@ -314,9 +339,7 @@ class StorageAccountHostsMixin(object):
 
         temp = request.multipart_mixed_info
         request.multipart_mixed_info = None
-        pipeline_response = self._pipeline.run(
-            request, **kwargs
-        )
+        pipeline_response = self._pipeline.run(request, **kwargs)
         response = pipeline_response.http_response
         request.multipart_mixed_info = temp
 
@@ -328,8 +351,7 @@ class StorageAccountHostsMixin(object):
                 parts = list(response.parts())
                 if any(p for p in parts if not 200 <= p.status_code < 300):
                     error = PartialBatchErrorException(
-                        message="There is a partial failure in the batch operation.",
-                        response=response, parts=parts
+                        message="There is a partial failure in the batch operation.", response=response, parts=parts
                     )
                     raise error
                 return iter(parts)
@@ -343,6 +365,7 @@ class TransportWrapper(HttpTransport):
     by a `get_client` method does not close the outer transport for the parent
     when used in a context manager.
     """
+
     def __init__(self, transport):
         self._transport = transport
 
@@ -364,7 +387,9 @@ class TransportWrapper(HttpTransport):
 
 def _format_shared_key_credential(
     account_name: Optional[str],
-    credential: Optional[Union[str, Dict[str, str], AzureNamedKeyCredential, AzureSasCredential, "AsyncTokenCredential", TokenCredential]] = None  # pylint: disable=line-too-long
+    credential: Optional[
+        Union[str, Dict[str, str], AzureNamedKeyCredential, AzureSasCredential, "AsyncTokenCredential", TokenCredential]
+    ] = None,
 ) -> Any:
     if isinstance(credential, str):
         if not account_name:
@@ -384,8 +409,12 @@ def _format_shared_key_credential(
 def parse_connection_str(
     conn_str: str,
     credential: Optional[Union[str, Dict[str, str], AzureNamedKeyCredential, AzureSasCredential, TokenCredential]],
-    service: str
-) -> Tuple[str, Optional[str], Optional[Union[str, Dict[str, str], AzureNamedKeyCredential, AzureSasCredential, TokenCredential]]]:  # pylint: disable=line-too-long
+    service: str,
+) -> Tuple[
+    str,
+    Optional[str],
+    Optional[Union[str, Dict[str, str], AzureNamedKeyCredential, AzureSasCredential, TokenCredential]],
+]:
     conn_str = conn_str.rstrip(";")
     conn_settings_list = [s.split("=", 1) for s in conn_str.split(";")]
     if any(len(tup) != 2 for tup in conn_settings_list):
@@ -407,14 +436,11 @@ def parse_connection_str(
         if endpoints["secondary"] in conn_settings:
             raise ValueError("Connection string specifies only secondary endpoint.")
         try:
-            primary =(
+            primary = (
                 f"{conn_settings['DEFAULTENDPOINTSPROTOCOL']}://"
                 f"{conn_settings['ACCOUNTNAME']}.{service}.{conn_settings['ENDPOINTSUFFIX']}"
             )
-            secondary = (
-                f"{conn_settings['ACCOUNTNAME']}-secondary."
-                f"{service}.{conn_settings['ENDPOINTSUFFIX']}"
-            )
+            secondary = f"{conn_settings['ACCOUNTNAME']}-secondary." f"{service}.{conn_settings['ENDPOINTSUFFIX']}"
         except KeyError:
             pass
 
@@ -434,7 +460,7 @@ def parse_connection_str(
 
 
 def create_configuration(**kwargs: Any) -> StorageConfiguration:
-     # Backwards compatibility if someone is not passing sdk_moniker
+    # Backwards compatibility if someone is not passing sdk_moniker
     if not kwargs.get("sdk_moniker"):
         kwargs["sdk_moniker"] = f"storage-{kwargs.pop('storage_sdk')}/{VERSION}"
     config = StorageConfiguration(**kwargs)

azure/storage/blob/_shared/base_client_async.py

@@ -64,18 +64,26 @@ class AsyncStorageAccountHostsMixin(object):
     async def __aexit__(self, *args):
         await self._client.__aexit__(*args)
 
-    async def close(self):
-        """ This method is to close the sockets opened by the client.
+    async def close(self) -> None:
+        """This method is to close the sockets opened by the client.
         It need not be used when using with a context manager.
+
+        :return: None
+        :rtype: None
         """
         await self._client.close()
 
     def _format_query_string(
-        self, sas_token: Optional[str],
-        credential: Optional[Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", AsyncTokenCredential]],  # pylint: disable=line-too-long
+        self,
+        sas_token: Optional[str],
+        credential: Optional[
+            Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", AsyncTokenCredential]
+        ],
         snapshot: Optional[str] = None,
-        share_snapshot: Optional[str] = None
-    ) -> Tuple[str, Optional[Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", AsyncTokenCredential]]]:  # pylint: disable=line-too-long
+        share_snapshot: Optional[str] = None,
+    ) -> Tuple[
+        str, Optional[Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", AsyncTokenCredential]]
+    ]:
         query_str = "?"
         if snapshot:
             query_str += f"snapshot={snapshot}&"
@@ -83,7 +91,8 @@ class AsyncStorageAccountHostsMixin(object):
             query_str += f"sharesnapshot={share_snapshot}&"
         if sas_token and isinstance(credential, AzureSasCredential):
             raise ValueError(
-                "You cannot use AzureSasCredential when the resource URI also contains a Shared Access Signature.")
+                "You cannot use AzureSasCredential when the resource URI also contains a Shared Access Signature."
+            )
         if _is_credential_sastoken(credential):
             query_str += credential.lstrip("?")  # type: ignore [union-attr]
             credential = None
@@ -92,35 +101,40 @@ class AsyncStorageAccountHostsMixin(object):
         return query_str.rstrip("?&"), credential
 
     def _create_pipeline(
-        self, credential: Optional[Union[str, Dict[str, str], AzureNamedKeyCredential, AzureSasCredential, AsyncTokenCredential]] = None, # pylint: disable=line-too-long
-        **kwargs: Any
+        self,
+        credential: Optional[
+            Union[str, Dict[str, str], AzureNamedKeyCredential, AzureSasCredential, AsyncTokenCredential]
+        ] = None,
+        **kwargs: Any,
     ) -> Tuple[StorageConfiguration, AsyncPipeline]:
         self._credential_policy: Optional[
-            Union[AsyncStorageBearerTokenCredentialPolicy,
-            SharedKeyCredentialPolicy,
-            AzureSasCredentialPolicy]] = None
-        if hasattr(credential, 'get_token'):
-            if kwargs.get('audience'):
-                audience = str(kwargs.pop('audience')).rstrip('/') + DEFAULT_OAUTH_SCOPE
+            Union[AsyncStorageBearerTokenCredentialPolicy, SharedKeyCredentialPolicy, AzureSasCredentialPolicy]
+        ] = None
+        if hasattr(credential, "get_token"):
+            if kwargs.get("audience"):
+                audience = str(kwargs.pop("audience")).rstrip("/") + DEFAULT_OAUTH_SCOPE
             else:
                 audience = STORAGE_OAUTH_SCOPE
             self._credential_policy = AsyncStorageBearerTokenCredentialPolicy(
-                                        cast(AsyncTokenCredential, credential), audience)
+                cast(AsyncTokenCredential, credential), audience
+            )
         elif isinstance(credential, SharedKeyCredentialPolicy):
             self._credential_policy = credential
         elif isinstance(credential, AzureSasCredential):
             self._credential_policy = AzureSasCredentialPolicy(credential)
         elif credential is not None:
             raise TypeError(f"Unsupported credential: {type(credential)}")
-        config = kwargs.get('_configuration') or create_configuration(**kwargs)
-        if kwargs.get('_pipeline'):
-            return config, kwargs['_pipeline']
-        transport = kwargs.get('transport')
+        config = kwargs.get("_configuration") or create_configuration(**kwargs)
+        if kwargs.get("_pipeline"):
+            return config, kwargs["_pipeline"]
+        transport = kwargs.get("transport")
         kwargs.setdefault("connection_timeout", CONNECTION_TIMEOUT)
         kwargs.setdefault("read_timeout", READ_TIMEOUT)
         if not transport:
             try:
-                from azure.core.pipeline.transport import AioHttpTransport  # pylint: disable=non-abstract-transport-import
+                from azure.core.pipeline.transport import (  # pylint: disable=non-abstract-transport-import
+                    AioHttpTransport,
+                )
             except ImportError as exc:
                 raise ImportError("Unable to create async transport. Please check aiohttp is installed.") from exc
             transport = AioHttpTransport(**kwargs)
@@ -143,53 +157,41 @@ class AsyncStorageAccountHostsMixin(object):
             HttpLoggingPolicy(**kwargs),
         ]
         if kwargs.get("_additional_pipeline_policies"):
-            policies = policies + kwargs.get("_additional_pipeline_policies")  #type: ignore
-        config.transport = transport #type: ignore
-        return config, AsyncPipeline(transport, policies=policies) #type: ignore
+            policies = policies + kwargs.get("_additional_pipeline_policies")  # type: ignore
+        config.transport = transport  # type: ignore
+        return config, AsyncPipeline(transport, policies=policies)  # type: ignore
 
-    async def _batch_send(
-        self,
-        *reqs: "HttpRequest",
-        **kwargs: Any
-    ) -> AsyncList["HttpResponse"]:
+    async def _batch_send(self, *reqs: "HttpRequest", **kwargs: Any) -> AsyncList["HttpResponse"]:
         """Given a series of request, do a Storage batch call.
 
         :param HttpRequest reqs: A collection of HttpRequest objects.
-        :returns: An AsyncList of HttpResponse objects.
+        :return: An AsyncList of HttpResponse objects.
         :rtype: AsyncList[HttpResponse]
         """
         # Pop it here, so requests doesn't feel bad about additional kwarg
         raise_on_any_failure = kwargs.pop("raise_on_any_failure", True)
         request = self._client._client.post(  # pylint: disable=protected-access
             url=(
-                f'{self.scheme}://{self.primary_hostname}/'
+                f"{self.scheme}://{self.primary_hostname}/"
                 f"{kwargs.pop('path', '')}?{kwargs.pop('restype', '')}"
                 f"comp=batch{kwargs.pop('sas', '')}{kwargs.pop('timeout', '')}"
             ),
-            headers={
-                'x-ms-version': self.api_version
-            }
+            headers={"x-ms-version": self.api_version},
         )
 
         policies = [StorageHeadersPolicy()]
         if self._credential_policy:
             policies.append(self._credential_policy)  # type: ignore
 
-        request.set_multipart_mixed(
-            *reqs,
-            policies=policies,
-            enforce_https=False
-        )
+        request.set_multipart_mixed(*reqs, policies=policies, enforce_https=False)
 
-        pipeline_response = await self._pipeline.run(
-            request, **kwargs
-        )
+        pipeline_response = await self._pipeline.run(request, **kwargs)
         response = pipeline_response.http_response
 
         try:
             if response.status_code not in [202]:
                 raise HttpResponseError(response=response)
-            parts = response.parts() # Return an AsyncIterator
+            parts = response.parts()  # Return an AsyncIterator
             if raise_on_any_failure:
                 parts_list = []
                 async for part in parts:
@@ -197,7 +199,8 @@ class AsyncStorageAccountHostsMixin(object):
                 if any(p for p in parts_list if not 200 <= p.status_code < 300):
                     error = PartialBatchErrorException(
                         message="There is a partial failure in the batch operation.",
-                        response=response, parts=parts_list
+                        response=response,
+                        parts=parts_list,
                     )
                     raise error
                 return AsyncList(parts_list)
@@ -205,11 +208,16 @@ class AsyncStorageAccountHostsMixin(object):
         except HttpResponseError as error:
             process_storage_error(error)
 
+
 def parse_connection_str(
     conn_str: str,
     credential: Optional[Union[str, Dict[str, str], AzureNamedKeyCredential, AzureSasCredential, AsyncTokenCredential]],
-    service: str
-) -> Tuple[str, Optional[str], Optional[Union[str, Dict[str, str], AzureNamedKeyCredential, AzureSasCredential, AsyncTokenCredential]]]: # pylint: disable=line-too-long
+    service: str,
+) -> Tuple[
+    str,
+    Optional[str],
+    Optional[Union[str, Dict[str, str], AzureNamedKeyCredential, AzureSasCredential, AsyncTokenCredential]],
+]:
     conn_str = conn_str.rstrip(";")
     conn_settings_list = [s.split("=", 1) for s in conn_str.split(";")]
     if any(len(tup) != 2 for tup in conn_settings_list):
@@ -231,14 +239,11 @@ def parse_connection_str(
         if endpoints["secondary"] in conn_settings:
             raise ValueError("Connection string specifies only secondary endpoint.")
         try:
-            primary =(
+            primary = (
                 f"{conn_settings['DEFAULTENDPOINTSPROTOCOL']}://"
                 f"{conn_settings['ACCOUNTNAME']}.{service}.{conn_settings['ENDPOINTSUFFIX']}"
             )
-            secondary = (
-                f"{conn_settings['ACCOUNTNAME']}-secondary."
-                f"{service}.{conn_settings['ENDPOINTSUFFIX']}"
-            )
+            secondary = f"{conn_settings['ACCOUNTNAME']}-secondary." f"{service}.{conn_settings['ENDPOINTSUFFIX']}"
         except KeyError:
             pass
 
@@ -256,11 +261,13 @@ def parse_connection_str(
             secondary = secondary.replace(".blob.", ".dfs.")
     return primary, secondary, credential
 
+
 class AsyncTransportWrapper(AsyncHttpTransport):
     """Wrapper class that ensures that an inner client created
     by a `get_client` method does not close the outer transport for the parent
     when used in a context manager.
     """
+
     def __init__(self, async_transport):
         self._transport = async_transport
 

azure/storage/blob/_shared/constants.py

@@ -16,4 +16,4 @@ READ_TIMEOUT = 60
 DEFAULT_OAUTH_SCOPE = "/.default"
 STORAGE_OAUTH_SCOPE = "https://storage.azure.com/.default"
 
-SERVICE_HOST_BASE = 'core.windows.net'
+SERVICE_HOST_BASE = "core.windows.net"