azure-storage-blob 12.21.0__py3-none-any.whl → 12.22.0__py3-none-any.whl

azure/storage/blob/aio/_list_blobs_helper.py

@@ -5,64 +5,62 @@
 # license information.
 # --------------------------------------------------------------------------
 
+from typing import Callable, List, Optional
 from urllib.parse import unquote
 
-from azure.core.async_paging import AsyncPageIterator, AsyncItemPaged
+from azure.core.async_paging import AsyncItemPaged, AsyncPageIterator
 from azure.core.exceptions import HttpResponseError
 
 from .._deserialize import (
     get_blob_properties_from_generated_code,
     load_many_xml_nodes,
     load_xml_int,
-    load_xml_string,
+    load_xml_string
 )
 from .._generated.models import BlobItemInternal, BlobPrefix as GenBlobPrefix
 from .._models import BlobProperties
 from .._shared.models import DictMixin
 from .._shared.response_handlers import (
-    return_context_and_deserialized,
-    return_raw_deserialized,
     process_storage_error,
+    return_context_and_deserialized,
+    return_raw_deserialized
 )
 
 
 class BlobPropertiesPaged(AsyncPageIterator):
-    """An Iterable of Blob properties.
+    """An Iterable of Blob properties."""
+
+    service_endpoint: Optional[str]
+    """The service URL."""
+    prefix: Optional[str]
+    """A blob name prefix being used to filter the list."""
+    marker: Optional[str]
+    """The continuation token of the current page of results."""
+    results_per_page: Optional[int]
+    """The maximum number of results retrieved per API call."""
+    continuation_token: Optional[str]
+    """The continuation token to retrieve the next page of results."""
+    location_mode: Optional[str]
+    """The location mode being used to list results. The available
+    options include "primary" and "secondary"."""
+    current_page: Optional[List[BlobProperties]]
+    """The current page of listed results."""
+    container: Optional[str]
+    """The container that the blobs are listed from."""
+    delimiter: Optional[str]
+    """A delimiting character used for hierarchy listing."""
+    command: Callable
+    """Function to retrieve the next page of items."""
 
-    :ivar str service_endpoint: The service URL.
-    :ivar str prefix: A blob name prefix being used to filter the list.
-    :ivar str marker: The continuation token of the current page of results.
-    :ivar int results_per_page: The maximum number of results retrieved per API call.
-    :ivar str location_mode: The location mode being used to list results. The available
-        options include "primary" and "secondary".
-    :ivar current_page: The current page of listed results.
-    :vartype current_page: list(~azure.storage.blob.models.BlobProperties)
-    :ivar str container: The container that the blobs are listed from.
-    :ivar str delimiter: A delimiting character used for hierarchy listing.
-
-    :param callable command: Function to retrieve the next page of items.
-    :param str container: The container that the blobs are listed from.
-    :param str prefix: Filters the results to return only blobs whose names
-        begin with the specified prefix.
-    :param int results_per_page: The maximum number of blobs to retrieve per
-        call.
-    :param str continuation_token: An opaque continuation token.
-    :param str delimiter:
-        Used to capture blobs whose names begin with the same substring up to
-        the appearance of the delimiter character. The delimiter may be a single
-        character or a string.
-    :param location_mode: Specifies the location the request should be sent to.
-        This mode only applies for RA-GRS accounts which allow secondary read access.
-        Options include 'primary' or 'secondary'.
-    """
     def __init__(
-            self, command,
-            container=None,
-            prefix=None,
-            results_per_page=None,
-            continuation_token=None,
-            delimiter=None,
-            location_mode=None):
+        self, command: Callable,
+        container: Optional[str] = None,
+        prefix: Optional[str] = None,
+        results_per_page: Optional[int] = None,
+        continuation_token: Optional[str] = None,
+        delimiter: Optional[str] = None,
+        location_mode: Optional[str] = None,
+    ) -> None:
         super(BlobPropertiesPaged, self).__init__(
             get_next=self._get_next_cb,
             extract_data=self._extract_data_cb,
@@ -105,44 +103,44 @@ class BlobPropertiesPaged(AsyncPageIterator):
             return item
         if isinstance(item, BlobItemInternal):
             blob = get_blob_properties_from_generated_code(item)  # pylint: disable=protected-access
-            blob.container = self.container
+            blob.container = self.container  # type: ignore [assignment]
             return blob
         return item
 
 
 class BlobNamesPaged(AsyncPageIterator):
-    """An Iterable of Blob names.
-
-    :ivar str service_endpoint: The service URL.
-    :ivar str prefix: A blob name prefix being used to filter the list.
-    :ivar str marker: The continuation token of the current page of results.
-    :ivar int results_per_page: The maximum number of results retrieved per API call.
-    :ivar str continuation_token: The continuation token to retrieve the next page of results.
-    :ivar str location_mode: The location mode being used to list results. The available
-        options include "primary" and "secondary".
-    :ivar current_page: The current page of listed results.
-    :vartype current_page: list(str)
-    :ivar str container: The container that the blobs are listed from.
-    :ivar str delimiter: A delimiting character used for hierarchy listing.
-
-    :param callable command: Function to retrieve the next page of items.
-    :param str container: The name of the container.
-    :param str prefix: Filters the results to return only blobs whose names
-        begin with the specified prefix.
-    :param int results_per_page: The maximum number of blobs to retrieve per
-        call.
-    :param str continuation_token: An opaque continuation token.
-    :param location_mode: Specifies the location the request should be sent to.
-        This mode only applies for RA-GRS accounts which allow secondary read access.
-        Options include 'primary' or 'secondary'.
-    """
+    """An Iterable of Blob names."""
+
+    service_endpoint: Optional[str]
+    """The service URL."""
+    prefix: Optional[str]
+    """A blob name prefix being used to filter the list."""
+    marker: Optional[str]
+    """The continuation token of the current page of results."""
+    results_per_page: Optional[int]
+    """The maximum number of blobs to retrieve per call."""
+    continuation_token: Optional[str]
+    """The continuation token to retrieve the next page of results."""
+    location_mode: Optional[str]
+    """The location mode being used to list results. The available
+    options include "primary" and "secondary"."""
+    current_page: Optional[List[BlobProperties]]
+    """The current page of listed results."""
+    container: Optional[str]
+    """The container that the blobs are listed from."""
+    delimiter: Optional[str]
+    """A delimiting character used for hierarchy listing."""
+    command: Callable
+    """Function to retrieve the next page of items."""
+
     def __init__(
-            self, command,
-            container=None,
-            prefix=None,
-            results_per_page=None,
-            continuation_token=None,
-            location_mode=None):
+        self, command: Callable,
+        container: Optional[str] = None,
+        prefix: Optional[str] = None,
+        results_per_page: Optional[int] = None,
+        continuation_token: Optional[str] = None,
+        location_mode: Optional[str] = None
+    ) -> None:
         super(BlobNamesPaged, self).__init__(
             get_next=self._get_next_cb,
             extract_data=self._extract_data_cb,
@@ -187,32 +185,32 @@ class BlobPrefix(AsyncItemPaged, DictMixin):
     """An Iterable of Blob properties.
 
     Returned from walk_blobs when a delimiter is used.
-    Can be thought of as a virtual blob directory.
-
-    :ivar str name: The prefix, or "directory name" of the blob.
-    :ivar str prefix: A blob name prefix being used to filter the list.
-    :ivar int results_per_page: The maximum number of results retrieved per API call.
-    :ivar str marker: The continuation token of the current page of results.
-    :ivar str location_mode: The location mode being used to list results. The available
-        options include "primary" and "secondary".
-    :ivar current_page: The current page of listed results.
-    :vartype current_page: list(~azure.storage.blob.models.BlobProperties)
-    :ivar str container: The container that the blobs are listed from.
-    :ivar str delimiter: A delimiting character used for hierarchy listing.
-    :param callable command: Function to retrieve the next page of items.
-    :param str prefix: Filters the results to return only blobs whose names
-        begin with the specified prefix.
-    :param int results_per_page: The maximum number of blobs to retrieve per
-        call.
-    :param str marker: An opaque continuation token.
-    :param str delimiter:
-        Used to capture blobs whose names begin with the same substring up to
-        the appearance of the delimiter character. The delimiter may be a single
-        character or a string.
-    :param location_mode: Specifies the location the request should be sent to.
-        This mode only applies for RA-GRS accounts which allow secondary read access.
-        Options include 'primary' or 'secondary'.
-    """
+    Can be thought of as a virtual blob directory."""
+
+    name: str
+    """The prefix, or "directory name" of the blob."""
+    service_endpoint: Optional[str]
+    """The service URL."""
+    prefix: str
+    """A blob name prefix being used to filter the list."""
+    marker: Optional[str]
+    """The continuation token of the current page of results."""
+    results_per_page: Optional[int]
+    """The maximum number of results retrieved per API call."""
+    next_marker: Optional[str]
+    """The continuation token to retrieve the next page of results."""
+    location_mode: str
+    """The location mode being used to list results. The available
+    options include "primary" and "secondary"."""
+    current_page: Optional[List[BlobProperties]]
+    """The current page of listed results."""
+    delimiter: str
+    """A delimiting character used for hierarchy listing."""
+    command: Callable
+    """Function to retrieve the next page of items."""
+    container: str
+    """The name of the container."""
+
     def __init__(self, *args, **kwargs):
         super(BlobPrefix, self).__init__(*args, page_iterator_class=BlobPrefixPaged, **kwargs)
         self.name = kwargs.get('prefix')

azure/storage/blob/aio/_models.py

@@ -6,35 +6,47 @@
 # pylint: disable=too-few-public-methods, too-many-instance-attributes
 # pylint: disable=super-init-not-called, too-many-lines
 
+from typing import Callable, List, Optional, TYPE_CHECKING
+
 from azure.core.async_paging import AsyncPageIterator
 from azure.core.exceptions import HttpResponseError
-from .._deserialize import parse_tags
 
+from .._deserialize import parse_tags
+from .._generated.models import FilterBlobItem
 from .._models import ContainerProperties, FilteredBlob, parse_page_list
-from .._shared.response_handlers import return_context_and_deserialized, process_storage_error
+from .._shared.response_handlers import process_storage_error, return_context_and_deserialized
 
-from .._generated.models import FilterBlobItem
+if TYPE_CHECKING:
+    from .._models import BlobProperties
 
 
 class ContainerPropertiesPaged(AsyncPageIterator):
     """An Iterable of Container properties.
 
-    :ivar str service_endpoint: The service URL.
-    :ivar str prefix: A container name prefix being used to filter the list.
-    :ivar str marker: The continuation token of the current page of results.
-    :ivar int results_per_page: The maximum number of results retrieved per API call.
-    :ivar str location_mode: The location mode being used to list results. The available
-        options include "primary" and "secondary".
-    :ivar current_page: The current page of listed results.
-    :vartype current_page: list(~azure.storage.blob.models.ContainerProperties)
-
-    :param callable command: Function to retrieve the next page of items.
-    :param str prefix: Filters the results to return only containers whose names
+    :param Callable command: Function to retrieve the next page of items.
+    :param Optional[str] prefix: Filters the results to return only containers whose names
         begin with the specified prefix.
-    :param int results_per_page: The maximum number of container names to retrieve per
+    :param Optional[int] results_per_page: The maximum number of container names to retrieve per
         call.
-    :param str continuation_token: An opaque continuation token.
+    :param Optional[str] continuation_token: An opaque continuation token.
     """
+
+    service_endpoint: Optional[str]
+    """The service URL."""
+    prefix: Optional[str]
+    """A container name prefix being used to filter the list."""
+    marker: Optional[str]
+    """The continuation token of the current page of results."""
+    results_per_page: Optional[int]
+    """The maximum number of results retrieved per API call."""
+    continuation_token: Optional[str]
+    """The continuation token to retrieve the next page of results."""
+    location_mode: Optional[str]
+    """The location mode being used to list results. The available
+        options include "primary" and "secondary"."""
+    current_page: List[ContainerProperties]
+    """The current page of listed results."""
+
     def __init__(self, command, prefix=None, results_per_page=None, continuation_token=None):
         super(ContainerPropertiesPaged, self).__init__(
             get_next=self._get_next_cb,
@@ -77,31 +89,41 @@ class ContainerPropertiesPaged(AsyncPageIterator):
 class FilteredBlobPaged(AsyncPageIterator):
     """An Iterable of Blob properties.
 
-    :ivar str service_endpoint: The service URL.
-    :ivar str prefix: A blob name prefix being used to filter the list.
-    :ivar str marker: The continuation token of the current page of results.
-    :ivar int results_per_page: The maximum number of results retrieved per API call.
-    :ivar str continuation_token: The continuation token to retrieve the next page of results.
-    :ivar str location_mode: The location mode being used to list results. The available
-        options include "primary" and "secondary".
-    :ivar current_page: The current page of listed results.
-    :vartype current_page: list(~azure.storage.blob.BlobProperties)
-    :ivar str container: The container that the blobs are listed from.
-    :param callable command: Function to retrieve the next page of items.
-    :param str container: The name of the container.
-    :param int results_per_page: The maximum number of blobs to retrieve per
+    :param Callable command: Function to retrieve the next page of items.
+    :param Optional[str] container: The name of the container.
+    :param Optional[int] results_per_page: The maximum number of blobs to retrieve per
         call.
-    :param str continuation_token: An opaque continuation token.
-    :param location_mode: Specifies the location the request should be sent to.
-        This mode only applies for RA-GRS accounts which allow secondary read access.
-        Options include 'primary' or 'secondary'.
+    :param Optional[str] continuation_token: An opaque continuation token.
+    :param Optional[str] location_mode:
+    Specifies the location the request should be sent to. This mode only applies for RA-GRS accounts
+        which allow secondary read access. Options include 'primary' or 'secondary'.
     """
+
+    service_endpoint: Optional[str]
+    """The service URL."""
+    prefix: Optional[str]
+    """A blob name prefix being used to filter the list."""
+    marker: Optional[str]
+    """The continuation token of the current page of results."""
+    results_per_page: Optional[int]
+    """The maximum number of results retrieved per API call."""
+    continuation_token: Optional[str]
+    """The continuation token to retrieve the next page of results."""
+    location_mode: Optional[str]
+    """The location mode being used to list results. The available
+        options include "primary" and "secondary"."""
+    current_page: Optional[List["BlobProperties"]]
+    """The current page of listed results."""
+    container: Optional[str]
+    """The container that the blobs are listed from."""
+
     def __init__(
-            self, command,
-            container=None,
-            results_per_page=None,
-            continuation_token=None,
-            location_mode=None):
+        self, command: Callable,
+        container: Optional[str] = None,
+        results_per_page: Optional[int] = None,
+        continuation_token: Optional[str] = None,
+        location_mode: Optional[str] = None
+    ) -> None:
         super(FilteredBlobPaged, self).__init__(
             get_next=self._get_next_cb,
             extract_data=self._extract_data_cb,

azure/storage/blob/aio/_upload_helpers.py

@@ -6,23 +6,10 @@
 
 import inspect
 from io import SEEK_SET, UnsupportedOperation
-from typing import TypeVar, TYPE_CHECKING
+from typing import Any, cast, Dict, IO, Optional, TypeVar, TYPE_CHECKING
 
-from azure.core.exceptions import ResourceModifiedError, HttpResponseError
+from azure.core.exceptions import HttpResponseError, ResourceModifiedError
 
-from .._shared.response_handlers import process_storage_error, return_response_headers
-from .._shared.uploads_async import (
-    upload_data_chunks,
-    upload_substream_blocks,
-    BlockBlobChunkUploader,
-    PageBlobChunkUploader,
-    AppendBlobChunkUploader
-)
-from .._generated.models import (
-    BlockLookupList,
-    AppendPositionAccessConditions,
-    ModifiedAccessConditions,
-)
 from ._encryption_async import GCMBlobEncryptionStream
 from .._encryption import (
     encrypt_blob,
@@ -32,23 +19,39 @@ from .._encryption import (
     _ENCRYPTION_PROTOCOL_V1,
     _ENCRYPTION_PROTOCOL_V2
 )
-from .._upload_helpers import _convert_mod_error, _any_conditions
+from .._generated.models import (
+    AppendPositionAccessConditions,
+    BlockLookupList,
+    ModifiedAccessConditions
+)
+from .._shared.response_handlers import process_storage_error, return_response_headers
+from .._shared.uploads_async import (
+    AppendBlobChunkUploader,
+    BlockBlobChunkUploader,
+    PageBlobChunkUploader,
+    upload_data_chunks,
+    upload_substream_blocks
+)
+from .._upload_helpers import _any_conditions, _convert_mod_error
 
 if TYPE_CHECKING:
+    from .._generated.aio.operations import AppendBlobOperations, BlockBlobOperations, PageBlobOperations
+    from .._shared.models import StorageConfiguration
     BlobLeaseClient = TypeVar("BlobLeaseClient")
 
 
 async def upload_block_blob(  # pylint: disable=too-many-locals, too-many-statements
-        client=None,
-        stream=None,
-        length=None,
-        overwrite=None,
-        headers=None,
-        validate_content=None,
-        max_concurrency=None,
-        blob_settings=None,
-        encryption_options=None,
-        **kwargs):
+    client: "BlockBlobOperations",
+    stream: IO,
+    overwrite: bool,
+    encryption_options: Dict[str, Any],
+    blob_settings: "StorageConfiguration",
+    headers: Dict[str, Any],
+    validate_content: bool,
+    max_concurrency: Optional[int],
+    length: Optional[int] = None,
+    **kwargs: Any
+) -> Dict[str, Any]:
     try:
         if not overwrite and not _any_conditions(**kwargs):
             kwargs['modified_access_conditions'].if_none_match = '*'
@@ -67,18 +70,20 @@ async def upload_block_blob(  # pylint: disable=too-many-locals, too-many-statem
 
         # Do single put if the size is smaller than config.max_single_put_size
         if adjusted_count is not None and (adjusted_count <= blob_settings.max_single_put_size):
-            data = stream.read(length)
+            data = stream.read(length or -1)
             if inspect.isawaitable(data):
                 data = await data
             if not isinstance(data, bytes):
                 raise TypeError('Blob data should be of type bytes.')
 
             if encryption_options.get('key'):
+                if not isinstance(data, bytes):
+                    raise TypeError('Blob data should be of type bytes.')
                 encryption_data, data = encrypt_blob(data, encryption_options['key'], encryption_options['version'])
                 headers['x-ms-meta-encryptiondata'] = encryption_data
 
-            response = await client.upload(
-                body=data,
+            response = cast(Dict[str, Any], await client.upload(
+                body=data,  # type: ignore [arg-type]
                 content_length=adjusted_count,
                 blob_http_headers=blob_headers,
                 headers=headers,
@@ -91,7 +96,7 @@ async def upload_block_blob(  # pylint: disable=too-many-locals, too-many-statem
                 immutability_policy_expiry=immutability_policy_expiry,
                 immutability_policy_mode=immutability_policy_mode,
                 legal_hold=legal_hold,
-                **kwargs)
+                **kwargs))
 
             if progress_hook:
                 await progress_hook(adjusted_count, adjusted_count)
@@ -108,10 +113,10 @@ async def upload_block_blob(  # pylint: disable=too-many-locals, too-many-statem
             total_size = length
             encryptor, padder = None, None
             if encryption_options and encryption_options.get('key'):
-                cek, iv, encryption_data = generate_blob_encryption_data(
+                cek, iv, encryption_metadata = generate_blob_encryption_data(
                     encryption_options['key'],
                     encryption_options['version'])
-                headers['x-ms-meta-encryptiondata'] = encryption_data
+                headers['x-ms-meta-encryptiondata'] = encryption_metadata
 
                 if encryption_options['version'] == _ENCRYPTION_PROTOCOL_V1:
                     encryptor, padder = get_blob_encryptor_and_padder(cek, iv, True)
@@ -121,7 +126,9 @@ async def upload_block_blob(  # pylint: disable=too-many-locals, too-many-statem
                     # Adjust total_size for encryption V2
                     total_size = adjusted_count
                     # V2 wraps the data stream with an encryption stream
-                    stream = GCMBlobEncryptionStream(cek, stream)
+                    if cek is None:
+                        raise ValueError("Generate encryption metadata failed. 'cek' is None.")
+                    stream = GCMBlobEncryptionStream(cek, stream)  # type: ignore [assignment]
 
             block_ids = await upload_data_chunks(
                 service=client,
@@ -153,7 +160,7 @@ async def upload_block_blob(  # pylint: disable=too-many-locals, too-many-statem
 
         block_lookup = BlockLookupList(committed=[], uncommitted=[], latest=[])
         block_lookup.latest = block_ids
-        return await client.commit_block_list(
+        return cast(Dict[str, Any], await client.commit_block_list(
             block_lookup,
             blob_http_headers=blob_headers,
             cls=return_response_headers,
@@ -164,7 +171,7 @@ async def upload_block_blob(  # pylint: disable=too-many-locals, too-many-statem
             immutability_policy_expiry=immutability_policy_expiry,
             immutability_policy_mode=immutability_policy_mode,
             legal_hold=legal_hold,
-            **kwargs)
+            **kwargs))
     except HttpResponseError as error:
         try:
             process_storage_error(error)
@@ -175,16 +182,17 @@ async def upload_block_blob(  # pylint: disable=too-many-locals, too-many-statem
 
 
 async def upload_page_blob(
-        client=None,
-        stream=None,
-        length=None,
-        overwrite=None,
-        headers=None,
-        validate_content=None,
-        max_concurrency=None,
-        blob_settings=None,
-        encryption_options=None,
-        **kwargs):
+    client: "PageBlobOperations",
+    overwrite: bool,
+    encryption_options: Dict[str, Any],
+    blob_settings: "StorageConfiguration",
+    headers: Dict[str, Any],
+    stream: IO,
+    length: Optional[int] = None,
+    validate_content: Optional[bool] = None,
+    max_concurrency: Optional[int] = None,
+    **kwargs: Any
+) -> Dict[str, Any]:
     try:
         if not overwrite and not _any_conditions(**kwargs):
             kwargs['modified_access_conditions'].if_none_match = '*'
@@ -210,18 +218,18 @@ async def upload_page_blob(
         blob_tags_string = kwargs.pop('blob_tags_string', None)
         progress_hook = kwargs.pop('progress_hook', None)
 
-        response = await client.create(
+        response = cast(Dict[str, Any], await client.create(
             content_length=0,
             blob_content_length=length,
-            blob_sequence_number=None,
+            blob_sequence_number=None,  # type: ignore [arg-type]
             blob_http_headers=kwargs.pop('blob_headers', None),
             blob_tags_string=blob_tags_string,
             tier=tier,
             cls=return_response_headers,
             headers=headers,
-            **kwargs)
+            **kwargs))
         if length == 0:
-            return response
+            return cast(Dict[str, Any], response)
 
         if encryption_options and encryption_options.get('key'):
             if encryption_options['version'] == _ENCRYPTION_PROTOCOL_V1:
@@ -230,7 +238,7 @@ async def upload_page_blob(
                 kwargs['padder'] = padder
 
         kwargs['modified_access_conditions'] = ModifiedAccessConditions(if_match=response['etag'])
-        return await upload_data_chunks(
+        return cast(Dict[str, Any], await upload_data_chunks(
             service=client,
             uploader_class=PageBlobChunkUploader,
             total_size=length,
@@ -240,7 +248,7 @@ async def upload_page_blob(
             validate_content=validate_content,
             progress_hook=progress_hook,
             headers=headers,
-            **kwargs)
+            **kwargs))
 
     except HttpResponseError as error:
         try:
@@ -252,16 +260,17 @@ async def upload_page_blob(
 
 
 async def upload_append_blob(  # pylint: disable=unused-argument
-        client=None,
-        stream=None,
-        length=None,
-        overwrite=None,
-        headers=None,
-        validate_content=None,
-        max_concurrency=None,
-        blob_settings=None,
-        encryption_options=None,
-        **kwargs):
+    client: "AppendBlobOperations",
+    overwrite: bool,
+    encryption_options: Dict[str, Any],
+    blob_settings: "StorageConfiguration",
+    headers: Dict[str, Any],
+    stream: IO,
+    length: Optional[int] = None,
+    validate_content: Optional[bool] = None,
+    max_concurrency: Optional[int] = None,
+    **kwargs: Any
+) -> Dict[str, Any]:
     try:
         if length == 0:
             return {}
@@ -280,7 +289,7 @@ async def upload_append_blob(  # pylint: disable=unused-argument
                     headers=headers,
                     blob_tags_string=blob_tags_string,
                     **kwargs)
-            return await upload_data_chunks(
+            return cast(Dict[str, Any], await upload_data_chunks(
                 service=client,
                 uploader_class=AppendBlobChunkUploader,
                 total_size=length,
@@ -291,9 +300,9 @@ async def upload_append_blob(  # pylint: disable=unused-argument
                 append_position_access_conditions=append_conditions,
                 progress_hook=progress_hook,
                 headers=headers,
-                **kwargs)
+                **kwargs))
         except HttpResponseError as error:
-            if error.response.status_code != 404:
+            if error.response.status_code != 404:  # type: ignore [union-attr]
                 raise
             # rewind the request body if it is a stream
             if hasattr(stream, 'read'):
@@ -309,7 +318,7 @@ async def upload_append_blob(  # pylint: disable=unused-argument
                 headers=headers,
                 blob_tags_string=blob_tags_string,
                 **kwargs)
-            return await upload_data_chunks(
+            return cast(Dict[str, Any], await upload_data_chunks(
                 service=client,
                 uploader_class=AppendBlobChunkUploader,
                 total_size=length,
@@ -320,6 +329,6 @@ async def upload_append_blob(  # pylint: disable=unused-argument
                 append_position_access_conditions=append_conditions,
                 progress_hook=progress_hook,
                 headers=headers,
-                **kwargs)
+                **kwargs))
     except HttpResponseError as error:
         process_storage_error(error)