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

azure/storage/blob/_container_client_helpers.py

@@ -0,0 +1,261 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+
+from typing import Any, Dict, List, Optional, Tuple, TYPE_CHECKING, Union
+from urllib.parse import quote, urlparse
+
+from azure.core import MatchConditions
+from azure.core.pipeline.transport import HttpRequest
+from ._blob_client_helpers import _generic_delete_blob_options
+from ._generated import AzureBlobStorage
+from ._models import BlobProperties
+from ._shared.base_client import parse_query
+
+if TYPE_CHECKING:
+    from azure.storage.blob import RehydratePriority
+    from urllib.parse import ParseResult
+    from ._generated.models import LeaseAccessConditions, ModifiedAccessConditions
+    from ._models import PremiumPageBlobTier, StandardBlobTier
+
+
+def _parse_url(account_url: str, container_name: str) -> Tuple["ParseResult", Any]:
+    try:
+        if not account_url.lower().startswith('http'):
+            account_url = "https://" + account_url
+    except AttributeError as exc:
+        raise ValueError("Container URL must be a string.") from exc
+    parsed_url = urlparse(account_url.rstrip('/'))
+    if not container_name:
+        raise ValueError("Please specify a container name.")
+    if not parsed_url.netloc:
+        raise ValueError(f"Invalid URL: {account_url}")
+
+    _, sas_token = parse_query(parsed_url.query)
+
+    return parsed_url, sas_token
+
+def _format_url(container_name: Union[bytes, str], hostname: str, scheme: str, query_str: str) -> str:
+    if isinstance(container_name, str):
+        container_name = container_name.encode('UTF-8')
+    return f"{scheme}://{hostname}/{quote(container_name)}{query_str}"
+
+# This code is a copy from _generated.
+# Once Autorest is able to provide request preparation this code should be removed.
+def _generate_delete_blobs_subrequest_options(
+    client: AzureBlobStorage,
+    snapshot: Optional[str] = None,
+    version_id: Optional[str] = None,
+    delete_snapshots: Optional[str] = None,
+    lease_access_conditions: Optional["LeaseAccessConditions"] = None,
+    modified_access_conditions: Optional["ModifiedAccessConditions"] = None,
+    **kwargs
+) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+    lease_id = None
+    if lease_access_conditions is not None:
+        lease_id = lease_access_conditions.lease_id
+    if_modified_since = None
+    if modified_access_conditions is not None:
+        if_modified_since = modified_access_conditions.if_modified_since
+    if_unmodified_since = None
+    if modified_access_conditions is not None:
+        if_unmodified_since = modified_access_conditions.if_unmodified_since
+    if_match = None
+    if modified_access_conditions is not None:
+        if_match = modified_access_conditions.if_match
+    if_none_match = None
+    if modified_access_conditions is not None:
+        if_none_match = modified_access_conditions.if_none_match
+    if_tags = None
+    if modified_access_conditions is not None:
+        if_tags = modified_access_conditions.if_tags
+
+    # Construct parameters
+    timeout = kwargs.pop('timeout', None)
+    query_parameters = {}
+    if snapshot is not None:
+        query_parameters['snapshot'] = client._serialize.query("snapshot", snapshot, 'str')  # pylint: disable=protected-access
+    if version_id is not None:
+        query_parameters['versionid'] = client._serialize.query("version_id", version_id, 'str')  # pylint: disable=protected-access
+    if timeout is not None:
+        query_parameters['timeout'] = client._serialize.query("timeout", timeout, 'int', minimum=0)  # pylint: disable=protected-access
+
+    # Construct headers
+    header_parameters = {}
+    if delete_snapshots is not None:
+        header_parameters['x-ms-delete-snapshots'] = client._serialize.header(  # pylint: disable=protected-access
+            "delete_snapshots", delete_snapshots, 'DeleteSnapshotsOptionType')
+    if lease_id is not None:
+        header_parameters['x-ms-lease-id'] = client._serialize.header(  # pylint: disable=protected-access
+            "lease_id", lease_id, 'str')
+    if if_modified_since is not None:
+        header_parameters['If-Modified-Since'] = client._serialize.header(  # pylint: disable=protected-access
+            "if_modified_since", if_modified_since, 'rfc-1123')
+    if if_unmodified_since is not None:
+        header_parameters['If-Unmodified-Since'] = client._serialize.header(  # pylint: disable=protected-access
+            "if_unmodified_since", if_unmodified_since, 'rfc-1123')
+    if if_match is not None:
+        header_parameters['If-Match'] = client._serialize.header(  # pylint: disable=protected-access
+            "if_match", if_match, 'str')
+    if if_none_match is not None:
+        header_parameters['If-None-Match'] = client._serialize.header(  # pylint: disable=protected-access
+            "if_none_match", if_none_match, 'str')
+    if if_tags is not None:
+        header_parameters['x-ms-if-tags'] = client._serialize.header("if_tags", if_tags, 'str')  # pylint: disable=protected-access
+
+    return query_parameters, header_parameters
+
+def _generate_delete_blobs_options(
+    query_str: str,
+    container_name: str,
+    client: AzureBlobStorage,
+    *blobs: Union[str, Dict[str, Any], BlobProperties],
+    **kwargs: Any
+) -> Tuple[List[HttpRequest], Dict[str, Any]]:
+    timeout = kwargs.pop('timeout', None)
+    raise_on_any_failure = kwargs.pop('raise_on_any_failure', True)
+    delete_snapshots = kwargs.pop('delete_snapshots', None)
+    if_modified_since = kwargs.pop('if_modified_since', None)
+    if_unmodified_since = kwargs.pop('if_unmodified_since', None)
+    if_tags_match_condition = kwargs.pop('if_tags_match_condition', None)
+    kwargs.update({'raise_on_any_failure': raise_on_any_failure,
+                    'sas': query_str.replace('?', '&'),
+                    'timeout': '&timeout=' + str(timeout) if timeout else "",
+                    'path': container_name,
+                    'restype': 'restype=container&'
+                    })
+
+    reqs = []
+    for blob in blobs:
+        if not isinstance(blob, str):
+            blob_name = blob.get('name')
+            options = _generic_delete_blob_options(  # pylint: disable=protected-access
+                snapshot=blob.get('snapshot'),
+                version_id=blob.get('version_id'),
+                delete_snapshots=delete_snapshots or blob.get('delete_snapshots'),
+                lease=blob.get('lease_id'),
+                if_modified_since=if_modified_since or blob.get('if_modified_since'),
+                if_unmodified_since=if_unmodified_since or blob.get('if_unmodified_since'),
+                etag=blob.get('etag'),
+                if_tags_match_condition=if_tags_match_condition or blob.get('if_tags_match_condition'),
+                match_condition=blob.get('match_condition') or MatchConditions.IfNotModified if blob.get('etag')
+                else None,
+                timeout=blob.get('timeout'),
+            )
+        else:
+            blob_name = blob
+            options = _generic_delete_blob_options(  # pylint: disable=protected-access
+                delete_snapshots=delete_snapshots,
+                if_modified_since=if_modified_since,
+                if_unmodified_since=if_unmodified_since,
+                if_tags_match_condition=if_tags_match_condition
+            )
+
+        query_parameters, header_parameters = _generate_delete_blobs_subrequest_options(client, **options)
+
+        req = HttpRequest(
+            "DELETE",
+            f"/{quote(container_name)}/{quote(str(blob_name), safe='/~')}{query_str}",
+            headers=header_parameters
+        )
+        req.format_parameters(query_parameters)
+        reqs.append(req)
+
+    return reqs, kwargs
+
+# This code is a copy from _generated.
+# Once Autorest is able to provide request preparation this code should be removed.
+def _generate_set_tiers_subrequest_options(
+    client: AzureBlobStorage,
+    tier: Optional[Union["PremiumPageBlobTier", "StandardBlobTier", str]],
+    snapshot: Optional[str] = None,
+    version_id: Optional[str] = None,
+    rehydrate_priority: Optional["RehydratePriority"] = None,
+    lease_access_conditions: Optional["LeaseAccessConditions"] = None,
+    **kwargs: Any
+) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+    if not tier:
+        raise ValueError("A blob tier must be specified")
+    if snapshot and version_id:
+        raise ValueError("Snapshot and version_id cannot be set at the same time")
+    if_tags = kwargs.pop('if_tags', None)
+
+    lease_id = None
+    if lease_access_conditions is not None:
+        lease_id = lease_access_conditions.lease_id
+
+    comp = "tier"
+    timeout = kwargs.pop('timeout', None)
+    # Construct parameters
+    query_parameters = {}
+    if snapshot is not None:
+        query_parameters['snapshot'] = client._serialize.query("snapshot", snapshot, 'str')  # pylint: disable=protected-access
+    if version_id is not None:
+        query_parameters['versionid'] = client._serialize.query("version_id", version_id, 'str')  # pylint: disable=protected-access
+    if timeout is not None:
+        query_parameters['timeout'] = client._serialize.query("timeout", timeout, 'int', minimum=0)  # pylint: disable=protected-access
+    query_parameters['comp'] = client._serialize.query("comp", comp, 'str')  # pylint: disable=protected-access, specify-parameter-names-in-call
+
+    # Construct headers
+    header_parameters = {}
+    header_parameters['x-ms-access-tier'] = client._serialize.header("tier", tier, 'str')  # pylint: disable=protected-access, specify-parameter-names-in-call
+    if rehydrate_priority is not None:
+        header_parameters['x-ms-rehydrate-priority'] = client._serialize.header(  # pylint: disable=protected-access
+            "rehydrate_priority", rehydrate_priority, 'str')
+    if lease_id is not None:
+        header_parameters['x-ms-lease-id'] = client._serialize.header("lease_id", lease_id, 'str')  # pylint: disable=protected-access
+    if if_tags is not None:
+        header_parameters['x-ms-if-tags'] = client._serialize.header("if_tags", if_tags, 'str')  # pylint: disable=protected-access
+
+    return query_parameters, header_parameters
+
+def _generate_set_tiers_options(
+    query_str: str,
+    container_name: str,
+    blob_tier: Optional[Union["PremiumPageBlobTier", "StandardBlobTier", str]],
+    client: AzureBlobStorage,
+    *blobs: Union[str, Dict[str, Any], BlobProperties],
+    **kwargs: Any
+) -> Tuple[List[HttpRequest], Dict[str, Any]]:
+    timeout = kwargs.pop('timeout', None)
+    raise_on_any_failure = kwargs.pop('raise_on_any_failure', True)
+    rehydrate_priority = kwargs.pop('rehydrate_priority', None)
+    if_tags = kwargs.pop('if_tags_match_condition', None)
+    kwargs.update({'raise_on_any_failure': raise_on_any_failure,
+                    'sas': query_str.replace('?', '&'),
+                    'timeout': '&timeout=' + str(timeout) if timeout else "",
+                    'path': container_name,
+                    'restype': 'restype=container&'
+                    })
+
+    reqs = []
+    for blob in blobs:
+        if not isinstance(blob, str):
+            blob_name = blob.get('name')
+            tier = blob_tier or blob.get('blob_tier')
+            query_parameters, header_parameters = _generate_set_tiers_subrequest_options(
+                client=client,
+                tier=tier,
+                snapshot=blob.get('snapshot'),
+                version_id=blob.get('version_id'),
+                rehydrate_priority=rehydrate_priority or blob.get('rehydrate_priority'),
+                lease_access_conditions=blob.get('lease_id'),
+                if_tags=if_tags or blob.get('if_tags_match_condition'),
+                timeout=timeout or blob.get('timeout')
+            )
+        else:
+            blob_name = blob
+            query_parameters, header_parameters = _generate_set_tiers_subrequest_options(
+                client, blob_tier, rehydrate_priority=rehydrate_priority, if_tags=if_tags)
+
+        req = HttpRequest(
+            "PUT",
+            f"/{quote(container_name)}/{quote(str(blob_name), safe='/~')}{query_str}",
+            headers=header_parameters
+        )
+        req.format_parameters(query_parameters)
+        reqs.append(req)
+
+    return reqs, kwargs

azure/storage/blob/_deserialize.py

@@ -4,10 +4,7 @@
 # license information.
 # --------------------------------------------------------------------------
 
-from typing import (
-    Dict, List, Optional, Tuple, Union,
-    TYPE_CHECKING
-)
+from typing import Any, Dict, List, Optional, Tuple, TYPE_CHECKING
 from urllib.parse import unquote
 from xml.etree.ElementTree import Element
 
@@ -25,16 +22,23 @@ from ._models import (
     ObjectReplicationPolicy,
     ObjectReplicationRule,
     RetentionPolicy,
-    StaticWebsite,
+    StaticWebsite
 )
 from ._shared.models import get_enum_value
 from ._shared.response_handlers import deserialize_metadata
 
 if TYPE_CHECKING:
-    from ._generated.models import BlobTag, PageList
-
+    from azure.core.pipeline import PipelineResponse
+    from ._generated.models import (
+        BlobItemInternal,
+        BlobTags,
+        PageList,
+        StorageServiceProperties,
+        StorageServiceStats,
+    )
+    from ._shared.models import LocationMode
 
-def deserialize_pipeline_response_into_cls(cls_method, response, obj, headers):
+def deserialize_pipeline_response_into_cls(cls_method, response: "PipelineResponse", obj: Any, headers: Dict[str, Any]):
     try:
         deserialized_response = response.http_response
     except AttributeError:
@@ -42,7 +46,7 @@ def deserialize_pipeline_response_into_cls(cls_method, response, obj, headers):
     return cls_method(deserialized_response, obj, headers)
 
 
-def deserialize_blob_properties(response, obj, headers):
+def deserialize_blob_properties(response: "PipelineResponse", obj: Any, headers: Dict[str, Any]) -> BlobProperties:
     blob_properties = BlobProperties(
         metadata=deserialize_metadata(response, obj, headers),
         object_replication_source_properties=deserialize_ors_policies(response.http_response.headers),
@@ -56,7 +60,7 @@ def deserialize_blob_properties(response, obj, headers):
     return blob_properties
 
 
-def deserialize_ors_policies(policy_dictionary):
+def deserialize_ors_policies(policy_dictionary: Optional[Dict[str, str]]) -> Optional[List[ObjectReplicationPolicy]]:
 
     if policy_dictionary is None:
         return None
@@ -66,7 +70,7 @@ def deserialize_ors_policies(policy_dictionary):
     or_policy_status_headers = {key: val for key, val in policy_dictionary.items()
                                 if 'or-' in key and key != 'x-ms-or-policy-id'}
 
-    parsed_result = {}
+    parsed_result: Dict[str, List[ObjectReplicationRule]] = {}
 
     for key, val in or_policy_status_headers.items():
         # list blobs gives or-policy_rule and get blob properties gives x-ms-or-policy_rule
@@ -83,13 +87,21 @@ def deserialize_ors_policies(policy_dictionary):
     return result_list
 
 
-def deserialize_blob_stream(response, obj, headers):
+def deserialize_blob_stream(
+    response: "PipelineResponse",
+    obj: Any,
+    headers: Dict[str, Any]
+) -> Tuple["LocationMode", Any]:
     blob_properties = deserialize_blob_properties(response, obj, headers)
     obj.properties = blob_properties
     return response.http_response.location_mode, obj
 
 
-def deserialize_container_properties(response, obj, headers):
+def deserialize_container_properties(
+    response: "PipelineResponse",
+    obj: Any,
+    headers: Dict[str, Any]
+) -> ContainerProperties:
     metadata = deserialize_metadata(response, obj, headers)
     container_properties = ContainerProperties(
         metadata=metadata,
@@ -98,65 +110,70 @@ def deserialize_container_properties(response, obj, headers):
     return container_properties
 
 
-def get_page_ranges_result(ranges):
-    # type: (PageList) -> Tuple[List[Dict[str, int]], List[Dict[str, int]]]
-    page_range = []  # type: ignore
-    clear_range = []  # type: List
+def get_page_ranges_result(ranges: "PageList") -> Tuple[List[Dict[str, int]], List[Dict[str, int]]]:
+    page_range = []
+    clear_range = []
     if ranges.page_range:
-        page_range = [{'start': b.start, 'end': b.end} for b in ranges.page_range]  # type: ignore
+        page_range = [{'start': b.start, 'end': b.end} for b in ranges.page_range]
     if ranges.clear_range:
         clear_range = [{'start': b.start, 'end': b.end} for b in ranges.clear_range]
-    return page_range, clear_range  # type: ignore
+    return page_range, clear_range
 
 
-# Deserialize a ServiceStats objects into a dict.
-def service_stats_deserialize(generated):
+def service_stats_deserialize(generated: "StorageServiceStats") -> Dict[str, Any]:
+    status = None
+    last_sync_time = None
+    if generated.geo_replication is not None:
+        status = generated.geo_replication.status
+        last_sync_time = generated.geo_replication.last_sync_time
     return {
         'geo_replication': {
-            'status': generated.geo_replication.status,
-            'last_sync_time': generated.geo_replication.last_sync_time,
+            'status': status,
+            'last_sync_time': last_sync_time
         }
     }
 
-# Deserialize a ServiceProperties objects into a dict.
-def service_properties_deserialize(generated):
+def service_properties_deserialize(generated: "StorageServiceProperties") -> Dict[str, Any]:
+    cors_list = None
+    if generated.cors is not None:
+        cors_list = [CorsRule._from_generated(cors) for cors in generated.cors]  # pylint: disable=protected-access
     return {
         'analytics_logging': BlobAnalyticsLogging._from_generated(generated.logging),  # pylint: disable=protected-access
         'hour_metrics': Metrics._from_generated(generated.hour_metrics),  # pylint: disable=protected-access
         'minute_metrics': Metrics._from_generated(generated.minute_metrics),  # pylint: disable=protected-access
-        'cors': [CorsRule._from_generated(cors) for cors in generated.cors],  # pylint: disable=protected-access
+        'cors': cors_list,
         'target_version': generated.default_service_version,  # pylint: disable=protected-access
         'delete_retention_policy': RetentionPolicy._from_generated(generated.delete_retention_policy),  # pylint: disable=protected-access
         'static_website': StaticWebsite._from_generated(generated.static_website),  # pylint: disable=protected-access
     }
 
 
-def get_blob_properties_from_generated_code(generated):
+def get_blob_properties_from_generated_code(generated: "BlobItemInternal") -> BlobProperties:
     blob = BlobProperties()
-    if generated.name.encoded:
+    if generated.name.encoded and generated.name.content is not None:
         blob.name = unquote(generated.name.content)
     else:
-        blob.name = generated.name.content
+        blob.name = generated.name.content  #type: ignore
     blob_type = get_enum_value(generated.properties.blob_type)
-    blob.blob_type = BlobType(blob_type) if blob_type else None
+    blob.blob_type = BlobType(blob_type)
     blob.etag = generated.properties.etag
     blob.deleted = generated.deleted
     blob.snapshot = generated.snapshot
     blob.is_append_blob_sealed = generated.properties.is_sealed
-    blob.metadata = generated.metadata.additional_properties if generated.metadata else {}
+    blob.metadata = generated.metadata.additional_properties if generated.metadata else {}  # type: ignore [assignment]
     blob.encrypted_metadata = generated.metadata.encrypted if generated.metadata else None
     blob.lease = LeaseProperties._from_generated(generated)  # pylint: disable=protected-access
     blob.copy = CopyProperties._from_generated(generated)  # pylint: disable=protected-access
     blob.last_modified = generated.properties.last_modified
-    blob.creation_time = generated.properties.creation_time
+    blob.creation_time = generated.properties.creation_time  # type: ignore [assignment]
     blob.content_settings = ContentSettings._from_generated(generated)  # pylint: disable=protected-access
-    blob.size = generated.properties.content_length
+    blob.size = generated.properties.content_length  # type: ignore [assignment]
     blob.page_blob_sequence_number = generated.properties.blob_sequence_number
-    blob.server_encrypted = generated.properties.server_encrypted
+    blob.server_encrypted = generated.properties.server_encrypted  # type: ignore [assignment]
     blob.encryption_scope = generated.properties.encryption_scope
     blob.deleted_time = generated.properties.deleted_time
     blob.remaining_retention_days = generated.properties.remaining_retention_days
-    blob.blob_tier = generated.properties.access_tier
+    blob.blob_tier = generated.properties.access_tier  # type: ignore [assignment]
     blob.rehydrate_priority = generated.properties.rehydrate_priority
     blob.blob_tier_inferred = generated.properties.access_tier_inferred
     blob.archive_status = generated.properties.archive_status
@@ -172,13 +189,13 @@ def get_blob_properties_from_generated_code(generated):
     blob.has_versions_only = generated.has_versions_only
     return blob
 
-def parse_tags(generated_tags: Optional[List["BlobTag"]]) -> Union[Dict[str, str], None]:
+def parse_tags(generated_tags: Optional["BlobTags"]) -> Optional[Dict[str, str]]:
     """Deserialize a list of BlobTag objects into a dict.
 
-    :param Optional[List[BlobTag]] generated_tags:
+    :param Optional[BlobTags] generated_tags:
         A list containing the BlobTag objects from generated code.
     :returns: A dictionary of the BlobTag objects.
-    :rtype: Dict[str, str] or None
+    :rtype: Optional[Dict[str, str]]
     """
     if generated_tags:
         tag_dict = {t.key: t.value for t in generated_tags.blob_tag_set}
@@ -186,24 +203,31 @@ def parse_tags(generated_tags: Optional[List["BlobTag"]]) -> Union[Dict[str, str
     return None
 
 
-def load_single_xml_node(element: Element, name: str) -> Union[Element, None]:
+def load_single_xml_node(element: Element, name: str) -> Optional[Element]:
     return element.find(name)
 
 
-def load_many_xml_nodes(element: Element, name: str, wrapper: Element = None) -> List[Union[Element, None]]:
+def load_many_xml_nodes(
+    element: Element,
+    name: str,
+    wrapper: Optional[str] = None
+) -> List[Optional[Element]]:
+    found_element: Optional[Element] = element
     if wrapper:
-        element = load_single_xml_node(element, wrapper)
-    return list(element.findall(name))
+        found_element = load_single_xml_node(element, wrapper)
+    if found_element is None:
+        return []
+    return list(found_element.findall(name))
 
 
-def load_xml_string(element: Element, name: str) -> str:
+def load_xml_string(element: Element, name: str) -> Optional[str]:
     node = element.find(name)
     if node is None or not node.text:
         return None
     return node.text
 
 
-def load_xml_int(element: Element, name: str) -> int:
+def load_xml_int(element: Element, name: str) -> Optional[int]:
     node = element.find(name)
     if node is None or not node.text:
         return None