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

azure/storage/blob/_shared/policies_async.py

@@ -5,7 +5,7 @@
 # --------------------------------------------------------------------------
 # pylint: disable=invalid-overridden-method
 
-import asyncio
+import asyncio  # pylint: disable=do-not-import-asyncio
 import logging
 import random
 from typing import Any, Dict, TYPE_CHECKING
@@ -21,7 +21,7 @@ if TYPE_CHECKING:
     from azure.core.credentials_async import AsyncTokenCredential
     from azure.core.pipeline.transport import (  # pylint: disable=non-abstract-transport-import
         PipelineRequest,
-        PipelineResponse
+        PipelineResponse,
     )
 
 
@@ -29,29 +29,25 @@ _LOGGER = logging.getLogger(__name__)
 
 
 async def retry_hook(settings, **kwargs):
-    if settings['hook']:
-        if asyncio.iscoroutine(settings['hook']):
-            await settings['hook'](
-                retry_count=settings['count'] - 1,
-                location_mode=settings['mode'],
-                **kwargs)
+    if settings["hook"]:
+        if asyncio.iscoroutine(settings["hook"]):
+            await settings["hook"](retry_count=settings["count"] - 1, location_mode=settings["mode"], **kwargs)
         else:
-            settings['hook'](
-                retry_count=settings['count'] - 1,
-                location_mode=settings['mode'],
-                **kwargs)
+            settings["hook"](retry_count=settings["count"] - 1, location_mode=settings["mode"], **kwargs)
 
 
 async def is_checksum_retry(response):
     # retry if invalid content md5
-    if response.context.get('validate_content', False) and response.http_response.headers.get('content-md5'):
-        try:
-            await response.http_response.load_body()  # Load the body in memory and close the socket
-        except (StreamClosedError, StreamConsumedError):
-            pass
-        computed_md5 = response.http_request.headers.get('content-md5', None) or \
-                       encode_base64(StorageContentValidation.get_content_md5(response.http_response.body()))
-        if response.http_response.headers['content-md5'] != computed_md5:
+    if response.context.get("validate_content", False) and response.http_response.headers.get("content-md5"):
+        if hasattr(response.http_response, "load_body"):
+            try:
+                await response.http_response.load_body()  # Load the body in memory and close the socket
+            except (StreamClosedError, StreamConsumedError):
+                pass
+        computed_md5 = response.http_request.headers.get("content-md5", None) or encode_base64(
+            StorageContentValidation.get_content_md5(response.http_response.body())
+        )
+        if response.http_response.headers["content-md5"] != computed_md5:
             return True
     return False
 
@@ -59,54 +55,56 @@ async def is_checksum_retry(response):
 class AsyncStorageResponseHook(AsyncHTTPPolicy):
 
     def __init__(self, **kwargs):
-        self._response_callback = kwargs.get('raw_response_hook')
+        self._response_callback = kwargs.get("raw_response_hook")
         super(AsyncStorageResponseHook, self).__init__()
 
     async def send(self, request: "PipelineRequest") -> "PipelineResponse":
         # Values could be 0
-        data_stream_total = request.context.get('data_stream_total')
+        data_stream_total = request.context.get("data_stream_total")
         if data_stream_total is None:
-            data_stream_total = request.context.options.pop('data_stream_total', None)
-        download_stream_current = request.context.get('download_stream_current')
+            data_stream_total = request.context.options.pop("data_stream_total", None)
+        download_stream_current = request.context.get("download_stream_current")
         if download_stream_current is None:
-            download_stream_current = request.context.options.pop('download_stream_current', None)
-        upload_stream_current = request.context.get('upload_stream_current')
+            download_stream_current = request.context.options.pop("download_stream_current", None)
+        upload_stream_current = request.context.get("upload_stream_current")
         if upload_stream_current is None:
-            upload_stream_current = request.context.options.pop('upload_stream_current', None)
+            upload_stream_current = request.context.options.pop("upload_stream_current", None)
 
-        response_callback = request.context.get('response_callback') or \
-            request.context.options.pop('raw_response_hook', self._response_callback)
+        response_callback = request.context.get("response_callback") or request.context.options.pop(
+            "raw_response_hook", self._response_callback
+        )
 
         response = await self.next.send(request)
-        will_retry = is_retry(response, request.context.options.get('mode')) or await is_checksum_retry(response)
+        will_retry = is_retry(response, request.context.options.get("mode")) or await is_checksum_retry(response)
 
         # Auth error could come from Bearer challenge, in which case this request will be made again
         is_auth_error = response.http_response.status_code == 401
         should_update_counts = not (will_retry or is_auth_error)
 
         if should_update_counts and download_stream_current is not None:
-            download_stream_current += int(response.http_response.headers.get('Content-Length', 0))
+            download_stream_current += int(response.http_response.headers.get("Content-Length", 0))
             if data_stream_total is None:
-                content_range = response.http_response.headers.get('Content-Range')
+                content_range = response.http_response.headers.get("Content-Range")
                 if content_range:
-                    data_stream_total = int(content_range.split(' ', 1)[1].split('/', 1)[1])
+                    data_stream_total = int(content_range.split(" ", 1)[1].split("/", 1)[1])
                 else:
                     data_stream_total = download_stream_current
         elif should_update_counts and upload_stream_current is not None:
-            upload_stream_current += int(response.http_request.headers.get('Content-Length', 0))
+            upload_stream_current += int(response.http_request.headers.get("Content-Length", 0))
         for pipeline_obj in [request, response]:
-            if hasattr(pipeline_obj, 'context'):
-                pipeline_obj.context['data_stream_total'] = data_stream_total
-                pipeline_obj.context['download_stream_current'] = download_stream_current
-                pipeline_obj.context['upload_stream_current'] = upload_stream_current
+            if hasattr(pipeline_obj, "context"):
+                pipeline_obj.context["data_stream_total"] = data_stream_total
+                pipeline_obj.context["download_stream_current"] = download_stream_current
+                pipeline_obj.context["upload_stream_current"] = upload_stream_current
         if response_callback:
             if asyncio.iscoroutine(response_callback):
-                await response_callback(response) # type: ignore
+                await response_callback(response)  # type: ignore
             else:
                 response_callback(response)
-            request.context['response_callback'] = response_callback
+            request.context["response_callback"] = response_callback
         return response
 
+
 class AsyncStorageRetryPolicy(StorageRetryPolicy):
     """
     The base class for Exponential and Linear retries containing shared code.
@@ -125,37 +123,29 @@ class AsyncStorageRetryPolicy(StorageRetryPolicy):
         while retries_remaining:
             try:
                 response = await self.next.send(request)
-                if is_retry(response, retry_settings['mode']) or await is_checksum_retry(response):
+                if is_retry(response, retry_settings["mode"]) or await is_checksum_retry(response):
                     retries_remaining = self.increment(
-                        retry_settings,
-                        request=request.http_request,
-                        response=response.http_response)
+                        retry_settings, request=request.http_request, response=response.http_response
+                    )
                     if retries_remaining:
                         await retry_hook(
-                            retry_settings,
-                            request=request.http_request,
-                            response=response.http_response,
-                            error=None)
+                            retry_settings, request=request.http_request, response=response.http_response, error=None
+                        )
                         await self.sleep(retry_settings, request.context.transport)
                         continue
                 break
             except AzureError as err:
                 if isinstance(err, AzureSigningError):
                     raise
-                retries_remaining = self.increment(
-                    retry_settings, request=request.http_request, error=err)
+                retries_remaining = self.increment(retry_settings, request=request.http_request, error=err)
                 if retries_remaining:
-                    await retry_hook(
-                        retry_settings,
-                        request=request.http_request,
-                        response=None,
-                        error=err)
+                    await retry_hook(retry_settings, request=request.http_request, response=None, error=err)
                     await self.sleep(retry_settings, request.context.transport)
                     continue
                 raise err
-        if retry_settings['history']:
-            response.context['history'] = retry_settings['history']
-        response.http_response.location_mode = retry_settings['mode']
+        if retry_settings["history"]:
+            response.context["history"] = retry_settings["history"]
+        response.http_response.location_mode = retry_settings["mode"]
         return response
 
 
@@ -176,7 +166,8 @@ class ExponentialRetry(AsyncStorageRetryPolicy):
         increment_base: int = 3,
         retry_total: int = 3,
         retry_to_secondary: bool = False,
-        random_jitter_range: int = 3, **kwargs
+        random_jitter_range: int = 3,
+        **kwargs
     ) -> None:
         """
         Constructs an Exponential retry object. The initial_backoff is used for
@@ -203,21 +194,20 @@ class ExponentialRetry(AsyncStorageRetryPolicy):
         self.initial_backoff = initial_backoff
         self.increment_base = increment_base
         self.random_jitter_range = random_jitter_range
-        super(ExponentialRetry, self).__init__(
-            retry_total=retry_total, retry_to_secondary=retry_to_secondary, **kwargs)
+        super(ExponentialRetry, self).__init__(retry_total=retry_total, retry_to_secondary=retry_to_secondary, **kwargs)
 
     def get_backoff_time(self, settings: Dict[str, Any]) -> float:
         """
         Calculates how long to sleep before retrying.
 
-        :param Dict[str, Any]] settings: The configurable values pertaining to the backoff time.
+        :param Dict[str, Any] settings: The configurable values pertaining to the backoff time.
         :return:
             An integer indicating how long to wait before retrying the request,
             or None to indicate no retry should be performed.
         :rtype: int or None
         """
         random_generator = random.Random()
-        backoff = self.initial_backoff + (0 if settings['count'] == 0 else pow(self.increment_base, settings['count']))
+        backoff = self.initial_backoff + (0 if settings["count"] == 0 else pow(self.increment_base, settings["count"]))
         random_range_start = backoff - self.random_jitter_range if backoff > self.random_jitter_range else 0
         random_range_end = backoff + self.random_jitter_range
         return random_generator.uniform(random_range_start, random_range_end)
@@ -232,7 +222,8 @@ class LinearRetry(AsyncStorageRetryPolicy):
     """A number in seconds which indicates a range to jitter/randomize for the back-off interval."""
 
     def __init__(
-        self, backoff: int = 15,
+        self,
+        backoff: int = 15,
         retry_total: int = 3,
         retry_to_secondary: bool = False,
         random_jitter_range: int = 3,
@@ -255,14 +246,13 @@ class LinearRetry(AsyncStorageRetryPolicy):
         """
         self.backoff = backoff
         self.random_jitter_range = random_jitter_range
-        super(LinearRetry, self).__init__(
-            retry_total=retry_total, retry_to_secondary=retry_to_secondary, **kwargs)
+        super(LinearRetry, self).__init__(retry_total=retry_total, retry_to_secondary=retry_to_secondary, **kwargs)
 
     def get_backoff_time(self, settings: Dict[str, Any]) -> float:
         """
         Calculates how long to sleep before retrying.
 
-        :param Dict[str, Any]] settings: The configurable values pertaining to the backoff time.
+        :param Dict[str, Any] settings: The configurable values pertaining to the backoff time.
         :return:
             An integer indicating how long to wait before retrying the request,
             or None to indicate no retry should be performed.
@@ -271,14 +261,13 @@ class LinearRetry(AsyncStorageRetryPolicy):
         random_generator = random.Random()
         # the backoff interval normally does not change, however there is the possibility
         # that it was modified by accessing the property directly after initializing the object
-        random_range_start = self.backoff - self.random_jitter_range \
-            if self.backoff > self.random_jitter_range else 0
+        random_range_start = self.backoff - self.random_jitter_range if self.backoff > self.random_jitter_range else 0
         random_range_end = self.backoff + self.random_jitter_range
         return random_generator.uniform(random_range_start, random_range_end)
 
 
 class AsyncStorageBearerTokenCredentialPolicy(AsyncBearerTokenCredentialPolicy):
-    """ Custom Bearer token credential policy for following Storage Bearer challenges """
+    """Custom Bearer token credential policy for following Storage Bearer challenges"""
 
     def __init__(self, credential: "AsyncTokenCredential", audience: str, **kwargs: Any) -> None:
         super(AsyncStorageBearerTokenCredentialPolicy, self).__init__(credential, audience, **kwargs)

azure/storage/blob/_shared/request_handlers.py

@@ -6,7 +6,7 @@
 
 import logging
 import stat
-from io import (SEEK_END, SEEK_SET, UnsupportedOperation)
+from io import SEEK_END, SEEK_SET, UnsupportedOperation
 from os import fstat
 from typing import Dict, Optional
 
@@ -37,12 +37,13 @@ def serialize_iso(attr):
             raise OverflowError("Hit max or min date")
 
         date = f"{utc.tm_year:04}-{utc.tm_mon:02}-{utc.tm_mday:02}T{utc.tm_hour:02}:{utc.tm_min:02}:{utc.tm_sec:02}"
-        return date + 'Z'
+        return date + "Z"
     except (ValueError, OverflowError) as err:
         raise ValueError("Unable to serialize datetime object.") from err
     except AttributeError as err:
         raise TypeError("ISO-8601 object must be valid datetime object.") from err
 
+
 def get_length(data):
     length = None
     # Check if object implements the __len__ method, covers most input cases such as bytearray.
@@ -62,7 +63,7 @@ def get_length(data):
             try:
                 mode = fstat(fileno).st_mode
                 if stat.S_ISREG(mode) or stat.S_ISLNK(mode):
-                    #st_size only meaningful if regular file or symlink, other types
+                    # st_size only meaningful if regular file or symlink, other types
                     # e.g. sockets may return misleading sizes like 0
                     return fstat(fileno).st_size
             except OSError:
@@ -84,13 +85,13 @@ def get_length(data):
 
 def read_length(data):
     try:
-        if hasattr(data, 'read'):
-            read_data = b''
+        if hasattr(data, "read"):
+            read_data = b""
             for chunk in iter(lambda: data.read(4096), b""):
                 read_data += chunk
             return len(read_data), read_data
-        if hasattr(data, '__iter__'):
-            read_data = b''
+        if hasattr(data, "__iter__"):
+            read_data = b""
             for chunk in data:
                 read_data += chunk
             return len(read_data), read_data
@@ -100,8 +101,13 @@ def read_length(data):
 
 
 def validate_and_format_range_headers(
-        start_range, end_range, start_range_required=True,
-        end_range_required=True, check_content_md5=False, align_to_page=False):
+    start_range,
+    end_range,
+    start_range_required=True,
+    end_range_required=True,
+    check_content_md5=False,
+    align_to_page=False,
+):
     # If end range is provided, start range must be provided
     if (start_range_required or end_range is not None) and start_range is None:
         raise ValueError("start_range value cannot be None.")
@@ -111,16 +117,18 @@ def validate_and_format_range_headers(
     # Page ranges must be 512 aligned
     if align_to_page:
         if start_range is not None and start_range % 512 != 0:
-            raise ValueError(f"Invalid page blob start_range: {start_range}. "
-                             "The size must be aligned to a 512-byte boundary.")
+            raise ValueError(
+                f"Invalid page blob start_range: {start_range}. " "The size must be aligned to a 512-byte boundary."
+            )
         if end_range is not None and end_range % 512 != 511:
-            raise ValueError(f"Invalid page blob end_range: {end_range}. "
-                             "The size must be aligned to a 512-byte boundary.")
+            raise ValueError(
+                f"Invalid page blob end_range: {end_range}. " "The size must be aligned to a 512-byte boundary."
+            )
 
     # Format based on whether end_range is present
     range_header = None
     if end_range is not None:
-        range_header = f'bytes={start_range}-{end_range}'
+        range_header = f"bytes={start_range}-{end_range}"
     elif start_range is not None:
         range_header = f"bytes={start_range}-"
 
@@ -131,17 +139,16 @@ def validate_and_format_range_headers(
             raise ValueError("Both start and end range required for MD5 content validation.")
         if end_range - start_range > 4 * 1024 * 1024:
             raise ValueError("Getting content MD5 for a range greater than 4MB is not supported.")
-        range_validation = 'true'
+        range_validation = "true"
 
     return range_header, range_validation
 
 
-def add_metadata_headers(metadata=None):
-    # type: (Optional[Dict[str, str]]) -> Dict[str, str]
+def add_metadata_headers(metadata: Optional[Dict[str, str]] = None) -> Dict[str, str]:
     headers = {}
     if metadata:
         for key, value in metadata.items():
-            headers[f'x-ms-meta-{key.strip()}'] = value.strip() if value else value
+            headers[f"x-ms-meta-{key.strip()}"] = value.strip() if value else value
     return headers
 
 
@@ -159,29 +166,26 @@ def serialize_batch_body(requests, batch_id):
         a list of sub-request for the batch request
     :param str batch_id:
         to be embedded in batch sub-request delimiter
-    :returns: The body bytes for this batch.
+    :return: The body bytes for this batch.
     :rtype: bytes
     """
 
     if requests is None or len(requests) == 0:
-        raise ValueError('Please provide sub-request(s) for this batch request')
+        raise ValueError("Please provide sub-request(s) for this batch request")
 
-    delimiter_bytes = (_get_batch_request_delimiter(batch_id, True, False) + _HTTP_LINE_ENDING).encode('utf-8')
-    newline_bytes = _HTTP_LINE_ENDING.encode('utf-8')
+    delimiter_bytes = (_get_batch_request_delimiter(batch_id, True, False) + _HTTP_LINE_ENDING).encode("utf-8")
+    newline_bytes = _HTTP_LINE_ENDING.encode("utf-8")
     batch_body = []
 
     content_index = 0
     for request in requests:
-        request.headers.update({
-            "Content-ID": str(content_index),
-            "Content-Length": str(0)
-        })
+        request.headers.update({"Content-ID": str(content_index), "Content-Length": str(0)})
         batch_body.append(delimiter_bytes)
         batch_body.append(_make_body_from_sub_request(request))
         batch_body.append(newline_bytes)
         content_index += 1
 
-    batch_body.append(_get_batch_request_delimiter(batch_id, True, True).encode('utf-8'))
+    batch_body.append(_get_batch_request_delimiter(batch_id, True, True).encode("utf-8"))
     # final line of body MUST have \r\n at the end, or it will not be properly read by the service
     batch_body.append(newline_bytes)
 
@@ -198,35 +202,35 @@ def _get_batch_request_delimiter(batch_id, is_prepend_dashes=False, is_append_da
         Whether to include the starting dashes. Used in the body, but non on defining the delimiter.
     :param bool is_append_dashes:
         Whether to include the ending dashes. Used in the body on the closing delimiter only.
-    :returns: The delimiter, WITHOUT a trailing newline.
+    :return: The delimiter, WITHOUT a trailing newline.
     :rtype: str
     """
 
-    prepend_dashes = '--' if is_prepend_dashes else ''
-    append_dashes = '--' if is_append_dashes else ''
+    prepend_dashes = "--" if is_prepend_dashes else ""
+    append_dashes = "--" if is_append_dashes else ""
 
     return prepend_dashes + _REQUEST_DELIMITER_PREFIX + batch_id + append_dashes
 
 
 def _make_body_from_sub_request(sub_request):
     """
-     Content-Type: application/http
-     Content-ID: <sequential int ID>
-     Content-Transfer-Encoding: <value> (if present)
+    Content-Type: application/http
+    Content-ID: <sequential int ID>
+    Content-Transfer-Encoding: <value> (if present)
 
-     <verb> <path><query> HTTP/<version>
-     <header key>: <header value> (repeated as necessary)
-     Content-Length: <value>
-     (newline if content length > 0)
-     <body> (if content length > 0)
+    <verb> <path><query> HTTP/<version>
+    <header key>: <header value> (repeated as necessary)
+    Content-Length: <value>
+    (newline if content length > 0)
+    <body> (if content length > 0)
 
-     Serializes an http request.
+    Serializes an http request.
 
-     :param ~azure.core.pipeline.transport.HttpRequest sub_request:
-        Request to serialize.
-     :returns: The serialized sub-request in bytes
-     :rtype: bytes
-     """
+    :param ~azure.core.pipeline.transport.HttpRequest sub_request:
+       Request to serialize.
+    :return: The serialized sub-request in bytes
+    :rtype: bytes
+    """
 
     # put the sub-request's headers into a list for efficient str concatenation
     sub_request_body = []
@@ -250,9 +254,9 @@ def _make_body_from_sub_request(sub_request):
 
     # append HTTP verb and path and query and HTTP version
     sub_request_body.append(sub_request.method)
-    sub_request_body.append(' ')
+    sub_request_body.append(" ")
     sub_request_body.append(sub_request.url)
-    sub_request_body.append(' ')
+    sub_request_body.append(" ")
     sub_request_body.append(_HTTP1_1_IDENTIFIER)
     sub_request_body.append(_HTTP_LINE_ENDING)
 
@@ -267,4 +271,4 @@ def _make_body_from_sub_request(sub_request):
     # append blank line
     sub_request_body.append(_HTTP_LINE_ENDING)
 
-    return ''.join(sub_request_body).encode()
+    return "".join(sub_request_body).encode()

azure/storage/blob/_shared/response_handlers.py

@@ -46,23 +46,23 @@ def parse_length_from_content_range(content_range):
     # First, split in space and take the second half: '1-3/65537'
     # Next, split on slash and take the second half: '65537'
     # Finally, convert to an int: 65537
-    return int(content_range.split(' ', 1)[1].split('/', 1)[1])
+    return int(content_range.split(" ", 1)[1].split("/", 1)[1])
 
 
 def normalize_headers(headers):
     normalized = {}
     for key, value in headers.items():
-        if key.startswith('x-ms-'):
+        if key.startswith("x-ms-"):
             key = key[5:]
-        normalized[key.lower().replace('-', '_')] = get_enum_value(value)
+        normalized[key.lower().replace("-", "_")] = get_enum_value(value)
     return normalized
 
 
 def deserialize_metadata(response, obj, headers):  # pylint: disable=unused-argument
     try:
-        raw_metadata = {k: v for k, v in response.http_response.headers.items() if k.lower().startswith('x-ms-meta-')}
+        raw_metadata = {k: v for k, v in response.http_response.headers.items() if k.lower().startswith("x-ms-meta-")}
     except AttributeError:
-        raw_metadata = {k: v for k, v in response.headers.items() if k.lower().startswith('x-ms-meta-')}
+        raw_metadata = {k: v for k, v in response.headers.items() if k.lower().startswith("x-ms-meta-")}
     return {k[10:]: v for k, v in raw_metadata.items()}
 
 
@@ -82,19 +82,23 @@ def return_raw_deserialized(response, *_):
     return response.http_response.location_mode, response.context[ContentDecodePolicy.CONTEXT_NAME]
 
 
-def process_storage_error(storage_error) -> NoReturn: # type: ignore [misc] # pylint:disable=too-many-statements, too-many-branches
+def process_storage_error(storage_error) -> NoReturn:  # type: ignore [misc] # pylint:disable=too-many-statements, too-many-branches
     raise_error = HttpResponseError
     serialized = False
     if isinstance(storage_error, AzureSigningError):
-        storage_error.message = storage_error.message + \
-            '. This is likely due to an invalid shared key. Please check your shared key and try again.'
+        storage_error.message = (
+            storage_error.message
+            + ". This is likely due to an invalid shared key. Please check your shared key and try again."
+        )
     if not storage_error.response or storage_error.response.status_code in [200, 204]:
         raise storage_error
     # If it is one of those three then it has been serialized prior by the generated layer.
-    if isinstance(storage_error, (PartialBatchErrorException,
-                                  ClientAuthenticationError, ResourceNotFoundError, ResourceExistsError)):
+    if isinstance(
+        storage_error,
+        (PartialBatchErrorException, ClientAuthenticationError, ResourceNotFoundError, ResourceExistsError),
+    ):
         serialized = True
-    error_code = storage_error.response.headers.get('x-ms-error-code')
+    error_code = storage_error.response.headers.get("x-ms-error-code")
     error_message = storage_error.message
     additional_data = {}
     error_dict = {}
@@ -104,27 +108,25 @@ def process_storage_error(storage_error) -> NoReturn: # type: ignore [misc] # py
             if error_body is None or len(error_body) == 0:
                 error_body = storage_error.response.reason
         except AttributeError:
-            error_body = ''
+            error_body = ""
         # If it is an XML response
         if isinstance(error_body, Element):
-            error_dict = {
-                child.tag.lower(): child.text
-                for child in error_body
-            }
+            error_dict = {child.tag.lower(): child.text for child in error_body}
         # If it is a JSON response
         elif isinstance(error_body, dict):
-            error_dict = error_body.get('error', {})
+            error_dict = error_body.get("error", {})
         elif not error_code:
             _LOGGER.warning(
-                'Unexpected return type %s from ContentDecodePolicy.deserialize_from_http_generics.', type(error_body))
-            error_dict = {'message': str(error_body)}
+                "Unexpected return type %s from ContentDecodePolicy.deserialize_from_http_generics.", type(error_body)
+            )
+            error_dict = {"message": str(error_body)}
 
         # If we extracted from a Json or XML response
         # There is a chance error_dict is just a string
         if error_dict and isinstance(error_dict, dict):
-            error_code = error_dict.get('code')
-            error_message = error_dict.get('message')
-            additional_data = {k: v for k, v in error_dict.items() if k not in {'code', 'message'}}
+            error_code = error_dict.get("code")
+            error_message = error_dict.get("message")
+            additional_data = {k: v for k, v in error_dict.items() if k not in {"code", "message"}}
     except DecodeError:
         pass
 
@@ -132,31 +134,33 @@ def process_storage_error(storage_error) -> NoReturn: # type: ignore [misc] # py
         # This check would be unnecessary if we have already serialized the error
         if error_code and not serialized:
             error_code = StorageErrorCode(error_code)
-            if error_code in [StorageErrorCode.condition_not_met,
-                              StorageErrorCode.blob_overwritten]:
+            if error_code in [StorageErrorCode.condition_not_met, StorageErrorCode.blob_overwritten]:
                 raise_error = ResourceModifiedError
-            if error_code in [StorageErrorCode.invalid_authentication_info,
-                              StorageErrorCode.authentication_failed]:
+            if error_code in [StorageErrorCode.invalid_authentication_info, StorageErrorCode.authentication_failed]:
                 raise_error = ClientAuthenticationError
-            if error_code in [StorageErrorCode.resource_not_found,
-                              StorageErrorCode.cannot_verify_copy_source,
-                              StorageErrorCode.blob_not_found,
-                              StorageErrorCode.queue_not_found,
-                              StorageErrorCode.container_not_found,
-                              StorageErrorCode.parent_not_found,
-                              StorageErrorCode.share_not_found]:
+            if error_code in [
+                StorageErrorCode.resource_not_found,
+                StorageErrorCode.cannot_verify_copy_source,
+                StorageErrorCode.blob_not_found,
+                StorageErrorCode.queue_not_found,
+                StorageErrorCode.container_not_found,
+                StorageErrorCode.parent_not_found,
+                StorageErrorCode.share_not_found,
+            ]:
                 raise_error = ResourceNotFoundError
-            if error_code in [StorageErrorCode.account_already_exists,
-                              StorageErrorCode.account_being_created,
-                              StorageErrorCode.resource_already_exists,
-                              StorageErrorCode.resource_type_mismatch,
-                              StorageErrorCode.blob_already_exists,
-                              StorageErrorCode.queue_already_exists,
-                              StorageErrorCode.container_already_exists,
-                              StorageErrorCode.container_being_deleted,
-                              StorageErrorCode.queue_being_deleted,
-                              StorageErrorCode.share_already_exists,
-                              StorageErrorCode.share_being_deleted]:
+            if error_code in [
+                StorageErrorCode.account_already_exists,
+                StorageErrorCode.account_being_created,
+                StorageErrorCode.resource_already_exists,
+                StorageErrorCode.resource_type_mismatch,
+                StorageErrorCode.blob_already_exists,
+                StorageErrorCode.queue_already_exists,
+                StorageErrorCode.container_already_exists,
+                StorageErrorCode.container_being_deleted,
+                StorageErrorCode.queue_being_deleted,
+                StorageErrorCode.share_already_exists,
+                StorageErrorCode.share_being_deleted,
+            ]:
                 raise_error = ResourceExistsError
     except ValueError:
         # Got an unknown error code
@@ -183,7 +187,7 @@ def process_storage_error(storage_error) -> NoReturn: # type: ignore [misc] # py
     error.args = (error.message,)
     try:
         # `from None` prevents us from double printing the exception (suppresses generated layer error context)
-        exec("raise error from None")   # pylint: disable=exec-used # nosec
+        exec("raise error from None")  # pylint: disable=exec-used # nosec
     except SyntaxError as exc:
         raise error from exc