azure-storage-blob 12.21.0b1__py3-none-any.whl → 12.23.0__py3-none-any.whl

azure/storage/blob/_quick_query_helper.py

@@ -5,37 +5,39 @@
 # --------------------------------------------------------------------------
 
 from io import BytesIO
-from typing import Union, Iterable, IO  # pylint: disable=unused-import
+from typing import Any, Dict, Generator, IO, Iterable, Optional, Type, Union, TYPE_CHECKING
 
-from ._shared.avro.datafile import DataFileReader
 from ._shared.avro.avro_io import DatumReader
+from ._shared.avro.datafile import DataFileReader
+
+if TYPE_CHECKING:
+    from ._models import BlobQueryError
 
 
 class BlobQueryReader(object):  # pylint: disable=too-many-instance-attributes
-    """A streaming object to read query results.
-
-    :ivar str name:
-        The name of the blob being quered.
-    :ivar str container:
-        The name of the container where the blob is.
-    :ivar dict response_headers:
-        The response_headers of the quick query request.
-    :ivar bytes record_delimiter:
-        The delimiter used to separate lines, or records with the data. The `records`
-        method will return these lines via a generator.
-    """
+    """A streaming object to read query results."""
+
+    name: str
+    """The name of the blob being quered."""
+    container: str
+    """The name of the container where the blob is."""
+    response_headers: Dict[str, Any]
+    """The response_headers of the quick query request."""
+    record_delimiter: str
+    """The delimiter used to separate lines, or records with the data. The `records`
+    method will return these lines via a generator."""
 
     def __init__(
         self,
-        name=None,
-        container=None,
-        errors=None,
-        record_delimiter='\n',
-        encoding=None,
-        headers=None,
-        response=None,
-        error_cls=None,
-    ):
+        name: str = None,  # type: ignore [assignment]
+        container: str = None,  # type: ignore [assignment]
+        errors: Any = None,
+        record_delimiter: str = '\n',
+        encoding: Optional[str] = None,
+        headers: Dict[str, Any] = None,  # type: ignore [assignment]
+        response: Any = None,
+        error_cls: Type["BlobQueryError"] = None,  # type: ignore [assignment]
+    ) -> None:
         self.name = name
         self.container = container
         self.response_headers = headers
@@ -51,7 +53,7 @@ class BlobQueryReader(object):  # pylint: disable=too-many-instance-attributes
     def __len__(self):
         return self._size
 
-    def _process_record(self, result):
+    def _process_record(self, result: Dict[str, Any]) -> Optional[bytes]:
         self._size = result.get('totalBytes', self._size)
         self._bytes_processed = result.get('bytesScanned', self._bytes_processed)
         if 'data' in result:
@@ -67,7 +69,7 @@ class BlobQueryReader(object):  # pylint: disable=too-many-instance-attributes
                 self._errors(error)
         return None
 
-    def _iter_stream(self):
+    def _iter_stream(self) -> Generator[bytes, None, None]:
         if self._first_result is not None:
             yield self._first_result
         for next_result in self._parsed_results:
@@ -75,8 +77,7 @@ class BlobQueryReader(object):  # pylint: disable=too-many-instance-attributes
             if processed_result is not None:
                 yield processed_result
 
-    def readall(self):
-        # type: () -> Union[bytes, str]
+    def readall(self) -> Union[bytes, str]:
         """Return all query results.
 
         This operation is blocking until all data is downloaded.
@@ -93,8 +94,7 @@ class BlobQueryReader(object):  # pylint: disable=too-many-instance-attributes
             return data.decode(self._encoding)
         return data
 
-    def readinto(self, stream):
-        # type: (IO) -> None
+    def readinto(self, stream: IO) -> None:
         """Download the query result to a stream.
 
         :param IO stream:
@@ -105,8 +105,7 @@ class BlobQueryReader(object):  # pylint: disable=too-many-instance-attributes
         for record in self._iter_stream():
             stream.write(record)
 
-    def records(self):
-        # type: () -> Iterable[Union[bytes, str]]
+    def records(self) -> Iterable[Union[bytes, str]]:
         """Returns a record generator for the query result.
 
         Records will be returned line by line.

azure/storage/blob/_serialize.py

@@ -3,9 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import (  # pylint: disable=unused-import
-    Any, Dict, Optional, Tuple, Union,
-    TYPE_CHECKING)
+from typing import Any, cast, Dict, Optional, Tuple, Union, TYPE_CHECKING
 
 try:
     from urllib.parse import quote
@@ -14,23 +12,22 @@ except ImportError:
 
 from azure.core import MatchConditions
 
-from ._models import (
-    ContainerEncryptionScope,
-    DelimitedJsonDialect)
 from ._generated.models import (
-    ModifiedAccessConditions,
-    SourceModifiedAccessConditions,
-    CpkScopeInfo,
+    ArrowConfiguration,
+    BlobTag,
+    BlobTags,
     ContainerCpkScopeInfo,
-    QueryFormat,
-    QuerySerialization,
+    CpkScopeInfo,
     DelimitedTextConfiguration,
     JsonTextConfiguration,
-    ArrowConfiguration,
+    LeaseAccessConditions,
+    ModifiedAccessConditions,
+    QueryFormat,
     QueryFormatType,
-    BlobTag,
-    BlobTags, LeaseAccessConditions
+    QuerySerialization,
+    SourceModifiedAccessConditions
 )
+from ._models import ContainerEncryptionScope, DelimitedJsonDialect
 
 if TYPE_CHECKING:
     from ._lease import BlobLeaseClient
@@ -59,11 +56,15 @@ _SUPPORTED_API_VERSIONS = [
     '2023-11-03',
     '2024-05-04',
     '2024-08-04',
+    '2024-11-04',
 ]
 
 
-def _get_match_headers(kwargs, match_param, etag_param):
-    # type: (Dict[str, Any], str, str) -> Tuple(Dict[str, Any], Optional[str], Optional[str])
+def _get_match_headers(
+    kwargs: Dict[str, Any],
+    match_param: str,
+    etag_param: str
+) -> Tuple[Optional[str], Optional[Any]]:
     if_match = None
     if_none_match = None
     match_condition = kwargs.pop(match_param, None)
@@ -87,8 +88,7 @@ def _get_match_headers(kwargs, match_param, etag_param):
     return if_match, if_none_match
 
 
-def get_access_conditions(lease):
-    # type: (Optional[Union[BlobLeaseClient, str]]) -> Union[LeaseAccessConditions, None]
+def get_access_conditions(lease: Optional[Union["BlobLeaseClient", str]]) -> Optional[LeaseAccessConditions]:
     try:
         lease_id = lease.id # type: ignore
     except AttributeError:
@@ -96,8 +96,7 @@ def get_access_conditions(lease):
     return LeaseAccessConditions(lease_id=lease_id) if lease_id else None
 
 
-def get_modify_conditions(kwargs):
-    # type: (Dict[str, Any]) -> ModifiedAccessConditions
+def get_modify_conditions(kwargs: Dict[str, Any]) -> ModifiedAccessConditions:
     if_match, if_none_match = _get_match_headers(kwargs, 'match_condition', 'etag')
     return ModifiedAccessConditions(
         if_modified_since=kwargs.pop('if_modified_since', None),
@@ -108,8 +107,7 @@ def get_modify_conditions(kwargs):
     )
 
 
-def get_source_conditions(kwargs):
-    # type: (Dict[str, Any]) -> SourceModifiedAccessConditions
+def get_source_conditions(kwargs: Dict[str, Any]) -> SourceModifiedAccessConditions:
     if_match, if_none_match = _get_match_headers(kwargs, 'source_match_condition', 'source_etag')
     return SourceModifiedAccessConditions(
         source_if_modified_since=kwargs.pop('source_if_modified_since', None),
@@ -120,15 +118,13 @@ def get_source_conditions(kwargs):
     )
 
 
-def get_cpk_scope_info(kwargs):
-    # type: (Dict[str, Any]) -> CpkScopeInfo
+def get_cpk_scope_info(kwargs: Dict[str, Any]) -> Optional[CpkScopeInfo]:
     if 'encryption_scope' in kwargs:
         return CpkScopeInfo(encryption_scope=kwargs.pop('encryption_scope'))
     return None
 
 
-def get_container_cpk_scope_info(kwargs):
-    # type: (Dict[str, Any]) -> ContainerCpkScopeInfo
+def get_container_cpk_scope_info(kwargs: Dict[str, Any]) -> Optional[ContainerCpkScopeInfo]:
     encryption_scope = kwargs.pop('container_encryption_scope', None)
     if encryption_scope:
         if isinstance(encryption_scope, ContainerEncryptionScope):
@@ -145,22 +141,19 @@ def get_container_cpk_scope_info(kwargs):
     return None
 
 
-def get_api_version(kwargs):
-    # type: (Dict[str, Any]) -> str
+def get_api_version(kwargs: Dict[str, Any]) -> str:
     api_version = kwargs.get('api_version', None)
     if api_version and api_version not in _SUPPORTED_API_VERSIONS:
         versions = '\n'.join(_SUPPORTED_API_VERSIONS)
         raise ValueError(f"Unsupported API version '{api_version}'. Please select from:\n{versions}")
     return api_version or _SUPPORTED_API_VERSIONS[-1]
 
-def get_version_id(self_vid, kwargs):
-    # type: (Optional[str], Dict[str, Any]) -> Optional[str]
+def get_version_id(self_vid: Optional[str], kwargs: Dict[str, Any]) -> Optional[str]:
     if 'version_id' in kwargs:
-        return kwargs.pop('version_id')
+        return cast(str, kwargs.pop('version_id'))
     return self_vid
 
-def serialize_blob_tags_header(tags=None):
-    # type: (Optional[Dict[str, str]]) -> str
+def serialize_blob_tags_header(tags: Optional[Dict[str, str]] = None) -> Optional[str]:
     if tags is None:
         return None
 
@@ -178,33 +171,27 @@ def serialize_blob_tags_header(tags=None):
     return ''.join(components)
 
 
-def serialize_blob_tags(tags=None):
-    # type: (Optional[Dict[str, str]]) -> Union[BlobTags, None]
+def serialize_blob_tags(tags: Optional[Dict[str, str]] = None) -> BlobTags:
     tag_list = []
     if tags:
         tag_list = [BlobTag(key=k, value=v) for k, v in tags.items()]
     return BlobTags(blob_tag_set=tag_list)
 
 
-def serialize_query_format(formater):
+def serialize_query_format(formater: Union[str, DelimitedJsonDialect]) -> Optional[QuerySerialization]:
     if formater == "ParquetDialect":
-        qq_format = QueryFormat(
-            type=QueryFormatType.PARQUET,
-            parquet_text_configuration=' '
-        )
+        qq_format = QueryFormat(type=QueryFormatType.PARQUET, parquet_text_configuration=' ')  #type: ignore [arg-type]
     elif isinstance(formater, DelimitedJsonDialect):
-        serialization_settings = JsonTextConfiguration(
-            record_separator=formater.delimiter
-        )
-        qq_format = QueryFormat(
-            type=QueryFormatType.json,
-            json_text_configuration=serialization_settings)
+        json_serialization_settings = JsonTextConfiguration(record_separator=formater.delimiter)
+        qq_format = QueryFormat(type=QueryFormatType.JSON, json_text_configuration=json_serialization_settings)
     elif hasattr(formater, 'quotechar'):  # This supports a csv.Dialect as well
         try:
-            headers = formater.has_header
+            headers = formater.has_header  # type: ignore
         except AttributeError:
             headers = False
-        serialization_settings = DelimitedTextConfiguration(
+        if isinstance(formater, str):
+            raise ValueError("Unknown string value provided. Accepted values: ParquetDialect")
+        csv_serialization_settings = DelimitedTextConfiguration(
             column_separator=formater.delimiter,
             field_quote=formater.quotechar,
             record_separator=formater.lineterminator,
@@ -212,16 +199,12 @@ def serialize_query_format(formater):
             headers_present=headers
         )
         qq_format = QueryFormat(
-            type=QueryFormatType.delimited,
-            delimited_text_configuration=serialization_settings
+            type=QueryFormatType.DELIMITED,
+            delimited_text_configuration=csv_serialization_settings
         )
     elif isinstance(formater, list):
-        serialization_settings = ArrowConfiguration(
-            schema=formater
-        )
-        qq_format = QueryFormat(
-            type=QueryFormatType.arrow,
-            arrow_configuration=serialization_settings)
+        arrow_serialization_settings = ArrowConfiguration(schema=formater)
+        qq_format = QueryFormat(type=QueryFormatType.arrow, arrow_configuration=arrow_serialization_settings)
     elif not formater:
         return None
     else:

azure/storage/blob/_shared/avro/datafile.py

@@ -185,7 +185,7 @@ class DataFileReader(object):  # pylint: disable=too-many-instance-attributes
 
         # check magic number
         if header.get('magic') != MAGIC:
-            fail_msg = f"Not an Avro data file: {header.get('magic')} doesn't match {MAGIC}."
+            fail_msg = f"Not an Avro data file: {header.get('magic')} doesn't match {MAGIC!r}."
             raise schema.AvroException(fail_msg)
 
         # set metadata

azure/storage/blob/_shared/avro/datafile_async.py

@@ -146,7 +146,7 @@ class AsyncDataFileReader(object):  # pylint: disable=too-many-instance-attribut
 
         # check magic number
         if header.get('magic') != MAGIC:
-            fail_msg = f"Not an Avro data file: {header.get('magic')} doesn't match {MAGIC}."
+            fail_msg = f"Not an Avro data file: {header.get('magic')} doesn't match {MAGIC!r}."
             raise schema.AvroException(fail_msg)
 
         # set metadata

azure/storage/blob/_shared/base_client.py

@@ -76,6 +76,7 @@ class StorageAccountHostsMixin(object):  # pylint: disable=too-many-instance-att
         self._location_mode = kwargs.get("_location_mode", LocationMode.PRIMARY)
         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}")
@@ -85,6 +86,7 @@ class StorageAccountHostsMixin(object):  # pylint: disable=too-many-instance-att
         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"):
+            self._is_localhost = True
             self.account_name = parsed_url.path.strip("/")
 
         self.credential = _format_shared_key_credential(self.account_name, credential)
@@ -331,7 +333,7 @@ class StorageAccountHostsMixin(object):  # pylint: disable=too-many-instance-att
                     )
                     raise error
                 return iter(parts)
-            return parts
+            return parts  # type: ignore [no-any-return]
         except HttpResponseError as error:
             process_storage_error(error)
 

azure/storage/blob/_shared/base_client_async.py

@@ -201,7 +201,7 @@ class AsyncStorageAccountHostsMixin(object):
                     )
                     raise error
                 return AsyncList(parts_list)
-            return parts
+            return parts  # type: ignore [no-any-return]
         except HttpResponseError as error:
             process_storage_error(error)
 

azure/storage/blob/_shared/policies.py

@@ -14,10 +14,10 @@ from io import SEEK_SET, UnsupportedOperation
 from time import time
 from typing import Any, Dict, Optional, TYPE_CHECKING
 from urllib.parse import (
-        parse_qsl,
-        urlencode,
-        urlparse,
-        urlunparse,
+    parse_qsl,
+    urlencode,
+    urlparse,
+    urlunparse,
 )
 from wsgiref.handlers import format_date_time
 
@@ -28,18 +28,13 @@ from azure.core.pipeline.policies import (
     HTTPPolicy,
     NetworkTraceLoggingPolicy,
     RequestHistory,
-    SansIOHTTPPolicy,
+    SansIOHTTPPolicy
 )
 
-from .authentication import StorageHttpChallenge
+from .authentication import AzureSigningError, StorageHttpChallenge
 from .constants import DEFAULT_OAUTH_SCOPE
 from .models import LocationMode
 
-try:
-    _unicode_type = unicode # type: ignore
-except NameError:
-    _unicode_type = str
-
 if TYPE_CHECKING:
     from azure.core.credentials import TokenCredential
     from azure.core.pipeline.transport import (  # pylint: disable=non-abstract-transport-import
@@ -52,7 +47,7 @@ _LOGGER = logging.getLogger(__name__)
 
 
 def encode_base64(data):
-    if isinstance(data, _unicode_type):
+    if isinstance(data, str):
         data = data.encode('utf-8')
     encoded = base64.b64encode(data)
     return encoded.decode('utf-8')
@@ -95,10 +90,14 @@ def is_retry(response, mode):   # pylint: disable=too-many-return-statements
         if status in [501, 505]:
             return False
         return True
+    return False
+
+
+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'):
         computed_md5 = response.http_request.headers.get('content-md5', None) or \
-                       encode_base64(StorageContentValidation.get_content_md5(response.http_response.body()))
+                            encode_base64(StorageContentValidation.get_content_md5(response.http_response.body()))
         if response.http_response.headers['content-md5'] != computed_md5:
             return True
     return False
@@ -301,7 +300,7 @@ class StorageResponseHook(HTTPPolicy):
 
         response = self.next.send(request)
 
-        will_retry = is_retry(response, request.context.options.get('mode'))
+        will_retry = is_retry(response, request.context.options.get('mode')) or 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)
@@ -527,7 +526,7 @@ class StorageRetryPolicy(HTTPPolicy):
         while retries_remaining:
             try:
                 response = self.next.send(request)
-                if is_retry(response, retry_settings['mode']):
+                if is_retry(response, retry_settings['mode']) or is_checksum_retry(response):
                     retries_remaining = self.increment(
                         retry_settings,
                         request=request.http_request,
@@ -542,6 +541,8 @@ class StorageRetryPolicy(HTTPPolicy):
                         continue
                 break
             except AzureError as err:
+                if isinstance(err, AzureSigningError):
+                    raise
                 retries_remaining = self.increment(
                     retry_settings, request=request.http_request, error=err)
                 if retries_remaining:

azure/storage/blob/_shared/policies_async.py

@@ -10,12 +10,12 @@ import logging
 import random
 from typing import Any, Dict, TYPE_CHECKING
 
-from azure.core.exceptions import AzureError
+from azure.core.exceptions import AzureError, StreamClosedError, StreamConsumedError
 from azure.core.pipeline.policies import AsyncBearerTokenCredentialPolicy, AsyncHTTPPolicy
 
-from .authentication import StorageHttpChallenge
+from .authentication import AzureSigningError, StorageHttpChallenge
 from .constants import DEFAULT_OAUTH_SCOPE
-from .policies import is_retry, StorageRetryPolicy
+from .policies import encode_base64, is_retry, StorageContentValidation, StorageRetryPolicy
 
 if TYPE_CHECKING:
     from azure.core.credentials_async import AsyncTokenCredential
@@ -42,6 +42,20 @@ async def retry_hook(settings, **kwargs):
                 **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.read()  # 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.content))
+        if response.http_response.headers['content-md5'] != computed_md5:
+            return True
+    return False
+
+
 class AsyncStorageResponseHook(AsyncHTTPPolicy):
 
     def __init__(self, **kwargs):  # pylint: disable=unused-argument
@@ -64,9 +78,8 @@ class AsyncStorageResponseHook(AsyncHTTPPolicy):
             request.context.options.pop('raw_response_hook', self._response_callback)
 
         response = await self.next.send(request)
-        await response.http_response.load_body()
+        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'))
         # 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)
@@ -112,7 +125,7 @@ class AsyncStorageRetryPolicy(StorageRetryPolicy):
         while retries_remaining:
             try:
                 response = await self.next.send(request)
-                if is_retry(response, retry_settings['mode']):
+                if is_retry(response, retry_settings['mode']) or await is_checksum_retry(response):
                     retries_remaining = self.increment(
                         retry_settings,
                         request=request.http_request,
@@ -127,6 +140,8 @@ class AsyncStorageRetryPolicy(StorageRetryPolicy):
                         continue
                 break
             except AzureError as err:
+                if isinstance(err, AzureSigningError):
+                    raise
                 retries_remaining = self.increment(
                     retry_settings, request=request.http_request, error=err)
                 if retries_remaining:

azure/storage/blob/_shared/response_handlers.py

@@ -17,7 +17,8 @@ from azure.core.exceptions import (
 )
 from azure.core.pipeline.policies import ContentDecodePolicy
 
-from .models import StorageErrorCode, UserDelegationKey, get_enum_value
+from .authentication import AzureSigningError
+from .models import get_enum_value, StorageErrorCode, UserDelegationKey
 from .parser import _to_utc_datetime
 
 
@@ -81,9 +82,12 @@ 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
+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.'
     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.

azure/storage/blob/_shared/shared_access_signature.py

@@ -107,8 +107,17 @@ class SharedAccessSignature(object):
         self.account_key = account_key
         self.x_ms_version = x_ms_version
 
-    def generate_account(self, services, resource_types, permission, expiry, start=None,
-                         ip=None, protocol=None, **kwargs):
+    def generate_account(
+        self, services,
+        resource_types,
+        permission,
+        expiry,
+        start=None,
+        ip=None,
+        protocol=None,
+        sts_hook=None,
+        **kwargs
+    ) -> str:
         '''
         Generates a shared access signature for the account.
         Use the returned signature with the sas_token parameter of the service
@@ -152,6 +161,10 @@ class SharedAccessSignature(object):
         :keyword str encryption_scope:
             Optional. If specified, this is the encryption scope to use when sending requests
             authorized with this SAS URI.
+        :param sts_hook:
+            For debugging purposes only. If provided, the hook is called with the string to sign
+            that was used to generate the SAS.
+        :type sts_hook: Optional[Callable[[str], None]]
         :returns: The generated SAS token for the account.
         :rtype: str
         '''
@@ -161,12 +174,16 @@ class SharedAccessSignature(object):
         sas.add_encryption_scope(**kwargs)
         sas.add_account_signature(self.account_name, self.account_key)
 
+        if sts_hook is not None:
+            sts_hook(sas.string_to_sign)
+
         return sas.get_token()
 
 
 class _SharedAccessHelper(object):
     def __init__(self):
         self.query_dict = {}
+        self.string_to_sign = ""
 
     def _add_query(self, name, val):
         if val:
@@ -229,6 +246,7 @@ class _SharedAccessHelper(object):
 
         self._add_query(QueryStringConstants.SIGNED_SIGNATURE,
                         sign_string(account_key, string_to_sign))
+        self.string_to_sign = string_to_sign
 
-    def get_token(self):
+    def get_token(self) -> str:
         return '&'.join([f'{n}={url_quote(v)}' for n, v in self.query_dict.items() if v is not None])

azure/storage/blob/_shared/uploads.py

@@ -12,7 +12,7 @@ from threading import Lock
 
 from azure.core.tracing.common import with_current_context
 
-from . import encode_base64, url_quote
+from .import encode_base64, url_quote
 from .request_handlers import get_length
 from .response_handlers import return_response_headers
 

azure/storage/blob/_shared/uploads_async.py

@@ -13,7 +13,7 @@ from itertools import islice
 from math import ceil
 from typing import AsyncGenerator, Union
 
-from . import encode_base64, url_quote
+from .import encode_base64, url_quote
 from .request_handlers import get_length
 from .response_handlers import return_response_headers
 from .uploads import SubStream, IterStreamer  # pylint: disable=unused-import