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

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.22.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: