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

azure/storage/blob/_shared_access_signature.py

@@ -5,25 +5,20 @@
 # --------------------------------------------------------------------------
 # pylint: disable=docstring-keyword-should-match-keyword-only
 
-from typing import (  # pylint: disable=unused-import
-    Union, Optional, Any, TYPE_CHECKING
+from typing import (
+    Any, Callable, Optional, Union,
+    TYPE_CHECKING
 )
 from urllib.parse import parse_qs
 
 from ._shared import sign_string, url_quote
 from ._shared.constants import X_MS_VERSION
 from ._shared.models import Services, UserDelegationKey
-from ._shared.shared_access_signature import SharedAccessSignature, _SharedAccessHelper, \
-    QueryStringConstants
+from ._shared.shared_access_signature import QueryStringConstants, SharedAccessSignature, _SharedAccessHelper
 
 if TYPE_CHECKING:
     from datetime import datetime
-    from ..blob import (
-        ResourceTypes,
-        AccountSasPermissions,
-        ContainerSasPermissions,
-        BlobSasPermissions
-    )
+    from ..blob import AccountSasPermissions, BlobSasPermissions, ContainerSasPermissions, ResourceTypes
 
 
 class BlobQueryStringConstants(object):
@@ -38,13 +33,17 @@ class BlobSharedAccessSignature(SharedAccessSignature):
     generate_*_shared_access_signature method directly.
     '''
 
-    def __init__(self, account_name, account_key=None, user_delegation_key=None):
+    def __init__(
+        self, account_name: str,
+        account_key: Optional[str] = None,
+        user_delegation_key: Optional[UserDelegationKey] = None
+    ) -> None:
         '''
         :param str account_name:
             The storage account name used to generate the shared access signatures.
-        :param str account_key:
+        :param Optional[str] account_key:
             The access key to generate the shares access signatures.
-        :param ~azure.storage.blob.models.UserDelegationKey user_delegation_key:
+        :param Optional[~azure.storage.blob.models.UserDelegationKey] user_delegation_key:
             Instead of an account key, the user could pass in a user delegation key.
             A user delegation key can be obtained from the service by authenticating with an AAD identity;
             this can be accomplished by calling get_user_delegation_key on any Blob service object.
@@ -52,11 +51,25 @@ class BlobSharedAccessSignature(SharedAccessSignature):
         super(BlobSharedAccessSignature, self).__init__(account_name, account_key, x_ms_version=X_MS_VERSION)
         self.user_delegation_key = user_delegation_key
 
-    def generate_blob(self, container_name, blob_name, snapshot=None, version_id=None, permission=None,
-                      expiry=None, start=None, policy_id=None, ip=None, protocol=None,
-                      cache_control=None, content_disposition=None,
-                      content_encoding=None, content_language=None,
-                      content_type=None, **kwargs):
+    def generate_blob(
+        self, container_name: str,
+        blob_name: str,
+        snapshot: Optional[str] = None,
+        version_id: Optional[str] = None,
+        permission: Optional[Union["BlobSasPermissions", str]] = None,
+        expiry: Optional[Union["datetime", str]] = None,
+        start: Optional[Union["datetime", str]] = None,
+        policy_id: Optional[str] = None,
+        ip: Optional[str] = None,
+        protocol: Optional[str] = None,
+        cache_control: Optional[str] = None,
+        content_disposition: Optional[str] = None,
+        content_encoding: Optional[str] = None,
+        content_language: Optional[str] = None,
+        content_type: Optional[str] = None,
+        sts_hook: Optional[Callable[[str], None]] = None,
+        **kwargs: Any
+    ) -> str:
         '''
         Generates a shared access signature for the blob or one of its snapshots.
         Use the returned signature with the sas_token parameter of any BlobService.
@@ -66,7 +79,7 @@ class BlobSharedAccessSignature(SharedAccessSignature):
         :param str blob_name:
             Name of blob.
         :param str snapshot:
-            The snapshot parameter is an opaque DateTime value that,
+            The snapshot parameter is an opaque datetime value that,
             when present, specifies the blob snapshot to grant permission.
         :param str version_id:
             An optional blob version ID. This parameter is only applicable for versioning-enabled
@@ -123,6 +136,10 @@ class BlobSharedAccessSignature(SharedAccessSignature):
         :param str content_type:
             Response header value for Content-Type when resource is accessed
             using this shared access signature.
+        :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]]
         :return: A Shared Access Signature (sas) token.
         :rtype: str
         '''
@@ -146,13 +163,27 @@ class BlobSharedAccessSignature(SharedAccessSignature):
         sas.add_resource_signature(self.account_name, self.account_key, resource_path,
                                    user_delegation_key=self.user_delegation_key)
 
+        if sts_hook is not None:
+            sts_hook(sas.string_to_sign)
+
         return sas.get_token()
 
-    def generate_container(self, container_name, permission=None, expiry=None,
-                           start=None, policy_id=None, ip=None, protocol=None,
-                           cache_control=None, content_disposition=None,
-                           content_encoding=None, content_language=None,
-                           content_type=None, **kwargs):
+    def generate_container(
+        self, container_name: str,
+        permission: Optional[Union["ContainerSasPermissions", str]] = None,
+        expiry: Optional[Union["datetime", str]] = None,
+        start: Optional[Union["datetime", str]] = None,
+        policy_id: Optional[str] = None,
+        ip: Optional[str] = None,
+        protocol: Optional[str] = None,
+        cache_control: Optional[str] = None,
+        content_disposition: Optional[str] = None,
+        content_encoding: Optional[str] = None,
+        content_language: Optional[str] = None,
+        content_type: Optional[str] = None,
+        sts_hook: Optional[Callable[[str], None]] = None,
+        **kwargs: Any
+    ) -> str:
         '''
         Generates a shared access signature for the container.
         Use the returned signature with the sas_token parameter of any BlobService.
@@ -209,6 +240,10 @@ class BlobSharedAccessSignature(SharedAccessSignature):
         :param str content_type:
             Response header value for Content-Type when resource is accessed
             using this shared access signature.
+        :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]]
         :return: A Shared Access Signature (sas) token.
         :rtype: str
         '''
@@ -223,6 +258,10 @@ class BlobSharedAccessSignature(SharedAccessSignature):
         sas.add_info_for_hns_account(**kwargs)
         sas.add_resource_signature(self.account_name, self.account_key, container_name,
                                    user_delegation_key=self.user_delegation_key)
+
+        if sts_hook is not None:
+            sts_hook(sas.string_to_sign)
+
         return sas.get_token()
 
 
@@ -297,8 +336,9 @@ class _BlobSharedAccessHelper(_SharedAccessHelper):
         self._add_query(QueryStringConstants.SIGNED_SIGNATURE,
                         sign_string(account_key if user_delegation_key is None else user_delegation_key.value,
                                     string_to_sign))
+        self.string_to_sign = string_to_sign
 
-    def get_token(self):
+    def get_token(self) -> str:
         # a conscious decision was made to exclude the timestamp in the generated token
         # this is to avoid having two snapshot ids in the query parameters when the user appends the snapshot timestamp
         exclude = [BlobQueryStringConstants.SIGNED_TIMESTAMP]
@@ -316,6 +356,7 @@ def generate_account_sas(
     ip: Optional[str] = None,
     *,
     services: Union[Services, str] = Services(blob=True),
+    sts_hook: Optional[Callable[[str], None]] = None,
     **kwargs: Any
 ) -> str:
     """Generates a shared access signature for the blob service.
@@ -357,6 +398,10 @@ def generate_account_sas(
         Specifies the protocol permitted for a request made. The default value is https.
     :keyword str encryption_scope:
         Specifies the encryption scope for a request made so that all write operations will be service encrypted.
+    :keyword sts_hook:
+        For debugging purposes only. If provided, the hook is called with the string to sign
+        that was used to generate the SAS.
+    :paramtype sts_hook: Optional[Callable[[str], None]]
     :return: A Shared Access Signature (sas) token.
     :rtype: str
 
@@ -377,23 +422,25 @@ def generate_account_sas(
         expiry=expiry,
         start=start,
         ip=ip,
+        sts_hook=sts_hook,
         **kwargs
-    ) # type: ignore
+    )
 
 
 def generate_container_sas(
-        account_name,  # type: str
-        container_name,  # type: str
-        account_key=None,  # type: Optional[str]
-        user_delegation_key=None,  # type: Optional[UserDelegationKey]
-        permission=None,  # type: Optional[Union[ContainerSasPermissions, str]]
-        expiry=None,  # type: Optional[Union[datetime, str]]
-        start=None,  # type: Optional[Union[datetime, str]]
-        policy_id=None,  # type: Optional[str]
-        ip=None,  # type: Optional[str]
-        **kwargs # type: Any
-    ):
-    # type: (...) -> Any
+    account_name: str,
+    container_name: str,
+    account_key: Optional[str] = None,
+    user_delegation_key: Optional[UserDelegationKey] = None,
+    permission: Optional[Union["ContainerSasPermissions", str]] = None,
+    expiry: Optional[Union["datetime", str]] = None,
+    start: Optional[Union["datetime", str]] = None,
+    policy_id: Optional[str] = None,
+    ip: Optional[str] = None,
+    *,
+    sts_hook: Optional[Callable[[str], None]] = None,
+    **kwargs: Any
+) -> str:
     """Generates a shared access signature for a container.
 
     Use the returned signature with the credential parameter of any BlobServiceClient,
@@ -465,6 +512,10 @@ def generate_container_sas(
     :keyword str correlation_id:
         The correlation id to correlate the storage audit logs with the audit logs used by the principal
         generating and distributing the SAS. This can only be used when generating a SAS with delegation key.
+    :keyword sts_hook:
+        For debugging purposes only. If provided, the hook is called with the string to sign
+        that was used to generate the SAS.
+    :paramtype sts_hook: Optional[Callable[[str], None]]
     :return: A Shared Access Signature (sas) token.
     :rtype: str
 
@@ -497,25 +548,27 @@ def generate_container_sas(
         start=start,
         policy_id=policy_id,
         ip=ip,
+        sts_hook=sts_hook,
         **kwargs
     )
 
 
 def generate_blob_sas(
-        account_name,  # type: str
-        container_name,  # type: str
-        blob_name,  # type: str
-        snapshot=None,  # type: Optional[str]
-        account_key=None,  # type: Optional[str]
-        user_delegation_key=None,  # type: Optional[UserDelegationKey]
-        permission=None,  # type: Optional[Union[BlobSasPermissions, str]]
-        expiry=None,  # type: Optional[Union[datetime, str]]
-        start=None,  # type: Optional[Union[datetime, str]]
-        policy_id=None,  # type: Optional[str]
-        ip=None,  # type: Optional[str]
-        **kwargs # type: Any
-    ):
-    # type: (...) -> Any
+    account_name: str,
+    container_name: str,
+    blob_name: str,
+    snapshot: Optional[str] = None,
+    account_key: Optional[str] = None,
+    user_delegation_key: Optional[UserDelegationKey] = None,
+    permission: Optional[Union["BlobSasPermissions", str]] = None,
+    expiry: Optional[Union["datetime", str]] = None,
+    start: Optional[Union["datetime", str]] = None,
+    policy_id: Optional[str] = None,
+    ip: Optional[str] = None,
+    *,
+    sts_hook: Optional[Callable[[str], None]] = None,
+    **kwargs: Any
+) -> str:
     """Generates a shared access signature for a blob.
 
     Use the returned signature with the credential parameter of any BlobServiceClient,
@@ -599,6 +652,10 @@ def generate_blob_sas(
     :keyword str correlation_id:
         The correlation id to correlate the storage audit logs with the audit logs used by the principal
         generating and distributing the SAS. This can only be used when generating a SAS with delegation key.
+    :keyword sts_hook:
+        For debugging purposes only. If provided, the hook is called with the string to sign
+        that was used to generate the SAS.
+    :paramtype sts_hook: Optional[Callable[[str], None]]
     :return: A Shared Access Signature (sas) token.
     :rtype: str
     """
@@ -628,6 +685,7 @@ def generate_blob_sas(
         start=start,
         policy_id=policy_id,
         ip=ip,
+        sts_hook=sts_hook,
         **kwargs
     )
 

azure/storage/blob/_upload_helpers.py

@@ -5,35 +5,37 @@
 # --------------------------------------------------------------------------
 
 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 ResourceExistsError, ResourceModifiedError, HttpResponseError
 
-from ._shared.response_handlers import process_storage_error, return_response_headers
-from ._shared.models import StorageErrorCode
-from ._shared.uploads import (
-    upload_data_chunks,
-    upload_substream_blocks,
-    BlockBlobChunkUploader,
-    PageBlobChunkUploader,
-    AppendBlobChunkUploader
+from ._encryption import (
+    _ENCRYPTION_PROTOCOL_V1,
+    _ENCRYPTION_PROTOCOL_V2,
+    encrypt_blob,
+    GCMBlobEncryptionStream,
+    generate_blob_encryption_data,
+    get_adjusted_upload_size,
+    get_blob_encryptor_and_padder
 )
 from ._generated.models import (
-    BlockLookupList,
     AppendPositionAccessConditions,
-    ModifiedAccessConditions,
+    BlockLookupList,
+    ModifiedAccessConditions
 )
-from ._encryption import (
-    GCMBlobEncryptionStream,
-    encrypt_blob,
-    get_adjusted_upload_size,
-    get_blob_encryptor_and_padder,
-    generate_blob_encryption_data,
-    _ENCRYPTION_PROTOCOL_V1,
-    _ENCRYPTION_PROTOCOL_V2
+from ._shared.models import StorageErrorCode
+from ._shared.response_handlers import process_storage_error, return_response_headers
+from ._shared.uploads import (
+    AppendBlobChunkUploader,
+    BlockBlobChunkUploader,
+    PageBlobChunkUploader,
+    upload_data_chunks,
+    upload_substream_blocks
 )
 
 if TYPE_CHECKING:
+    from ._generated.operations import AppendBlobOperations, BlockBlobOperations, PageBlobOperations
+    from ._shared.models import StorageConfiguration
     BlobLeaseClient = TypeVar("BlobLeaseClient")
 
 _LARGE_BLOB_UPLOAD_MAX_READ_BUFFER_SIZE = 4 * 1024 * 1024
@@ -63,16 +65,17 @@ def _any_conditions(modified_access_conditions=None, **kwargs):  # pylint: disab
 
 
 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 = '*'
@@ -91,7 +94,7 @@ def upload_block_blob(  # pylint: disable=too-many-locals, too-many-statements
 
         # Do single put if the size is smaller than or equal 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 not isinstance(data, bytes):
                 raise TypeError('Blob data should be of type bytes.')
 
@@ -100,7 +103,7 @@ def upload_block_blob(  # pylint: disable=too-many-locals, too-many-statements
                 headers['x-ms-meta-encryptiondata'] = encryption_data
 
             response = client.upload(
-                body=data,
+                body=data,  # type: ignore [arg-type]
                 content_length=adjusted_count,
                 blob_http_headers=blob_headers,
                 headers=headers,
@@ -118,7 +121,7 @@ def upload_block_blob(  # pylint: disable=too-many-locals, too-many-statements
             if progress_hook:
                 progress_hook(adjusted_count, adjusted_count)
 
-            return response
+            return cast(Dict[str, Any], response)
 
         use_original_upload_path = blob_settings.use_byte_buffer or \
             validate_content or encryption_options.get('required') or \
@@ -130,10 +133,10 @@ def upload_block_blob(  # pylint: disable=too-many-locals, too-many-statements
             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)
@@ -143,7 +146,9 @@ def upload_block_blob(  # pylint: disable=too-many-locals, too-many-statements
                     # 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 = upload_data_chunks(
                 service=client,
@@ -175,7 +180,7 @@ def upload_block_blob(  # pylint: disable=too-many-locals, too-many-statements
 
         block_lookup = BlockLookupList(committed=[], uncommitted=[], latest=[])
         block_lookup.latest = block_ids
-        return client.commit_block_list(
+        return cast(Dict[str, Any], client.commit_block_list(
             block_lookup,
             blob_http_headers=blob_headers,
             cls=return_response_headers,
@@ -186,7 +191,7 @@ def upload_block_blob(  # pylint: disable=too-many-locals, too-many-statements
             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)
@@ -197,16 +202,17 @@ def upload_block_blob(  # pylint: disable=too-many-locals, too-many-statements
 
 
 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 = '*'
@@ -232,18 +238,18 @@ def upload_page_blob(
         blob_tags_string = kwargs.pop('blob_tags_string', None)
         progress_hook = kwargs.pop('progress_hook', None)
 
-        response = client.create(
+        response = cast(Dict[str, Any], 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:
@@ -252,7 +258,7 @@ def upload_page_blob(
                 kwargs['padder'] = padder
 
         kwargs['modified_access_conditions'] = ModifiedAccessConditions(if_match=response['etag'])
-        return upload_data_chunks(
+        return cast(Dict[str, Any], upload_data_chunks(
             service=client,
             uploader_class=PageBlobChunkUploader,
             total_size=length,
@@ -262,7 +268,7 @@ def upload_page_blob(
             validate_content=validate_content,
             progress_hook=progress_hook,
             headers=headers,
-            **kwargs)
+            **kwargs))
 
     except HttpResponseError as error:
         try:
@@ -274,16 +280,17 @@ def upload_page_blob(
 
 
 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 {}
@@ -302,7 +309,7 @@ def upload_append_blob(  # pylint: disable=unused-argument
                     headers=headers,
                     blob_tags_string=blob_tags_string,
                     **kwargs)
-            return upload_data_chunks(
+            return cast(Dict[str, Any], upload_data_chunks(
                 service=client,
                 uploader_class=AppendBlobChunkUploader,
                 total_size=length,
@@ -313,9 +320,9 @@ 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'):
@@ -331,7 +338,7 @@ def upload_append_blob(  # pylint: disable=unused-argument
                 headers=headers,
                 blob_tags_string=blob_tags_string,
                 **kwargs)
-            return upload_data_chunks(
+            return cast(Dict[str, Any], upload_data_chunks(
                 service=client,
                 uploader_class=AppendBlobChunkUploader,
                 total_size=length,
@@ -342,6 +349,6 @@ 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)

azure/storage/blob/_version.py

@@ -4,4 +4,4 @@
 # license information.
 # --------------------------------------------------------------------------
 
-VERSION = "12.21.0b1"
+VERSION = "12.23.0"

azure/storage/blob/aio/__init__.py

@@ -7,6 +7,7 @@
 
 import os
 
+from typing import Any, AnyStr, Dict, cast, IO, Iterable, Optional, Union, TYPE_CHECKING
 from ._list_blobs_helper import BlobPrefix
 from .._models import BlobType
 from .._shared.policies_async import ExponentialRetry, LinearRetry
@@ -16,13 +17,17 @@ from ._blob_service_client_async import BlobServiceClient
 from ._lease_async import BlobLeaseClient
 from ._download_async import StorageStreamDownloader
 
+if TYPE_CHECKING:
+    from azure.core.credentials import AzureNamedKeyCredential, AzureSasCredential
+    from azure.core.credentials_async import AsyncTokenCredential
+
 
 async def upload_blob_to_url(
-        blob_url,  # type: str
-        data,  # type: Union[Iterable[AnyStr], IO[AnyStr]]
-        credential=None,  # type: Optional[Union[str, Dict[str, str], AzureNamedKeyCredential, AzureSasCredential, "TokenCredential"]] # pylint: disable=line-too-long
-        **kwargs):
-    # type: (...) -> dict[str, Any]
+    blob_url: str,
+    data: Union[Iterable[AnyStr], IO[AnyStr]],
+    credential: Optional[Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "AsyncTokenCredential"]] = None,  # pylint: disable=line-too-long
+    **kwargs: Any
+) -> Dict[str, Any]:
     """Upload data to a given URL
 
     The data will be uploaded as a block blob.
@@ -72,7 +77,10 @@ async def upload_blob_to_url(
     :rtype: dict[str, Any]
     """
     async with BlobClient.from_blob_url(blob_url, credential=credential) as client:
-        return await client.upload_blob(data=data, blob_type=BlobType.BlockBlob, **kwargs)
+        return await cast(BlobClient, client).upload_blob(
+            data=data,
+            blob_type=BlobType.BLOCKBLOB,
+            **kwargs)
 
 
 # Download data to specified open file-handle.
@@ -82,11 +90,11 @@ async def _download_to_stream(client, handle, **kwargs):
 
 
 async def download_blob_from_url(
-        blob_url,  # type: str
-        output,  # type: str
-        credential=None,  # type: Optional[Union[str, Dict[str, str], AzureNamedKeyCredential, AzureSasCredential, "TokenCredential"]] # pylint: disable=line-too-long
-        **kwargs):
-    # type: (...) -> None
+    blob_url: str,
+    output: str,
+    credential: Optional[Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "AsyncTokenCredential"]] = None, # pylint: disable=line-too-long
+    **kwargs: Any
+) -> None:
     """Download the contents of a blob to a local file or stream.
 
     :param str blob_url: