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

azure/storage/blob/_models.py

@@ -7,7 +7,7 @@
 # pylint: disable=super-init-not-called, too-many-lines
 
 from enum import Enum
-from typing import Dict, List, Optional, TYPE_CHECKING
+from typing import Any, Callable, Dict, List, Optional, Union, TYPE_CHECKING
 
 from azure.core import CaseInsensitiveEnumMeta
 from azure.core.paging import PageIterator
@@ -16,23 +16,29 @@ from azure.core.exceptions import HttpResponseError
 from ._shared import decode_base64_to_bytes
 from ._shared.response_handlers import return_context_and_deserialized, process_storage_error
 from ._shared.models import DictMixin, get_enum_value
+from ._generated.models import AccessPolicy as GenAccessPolicy
 from ._generated.models import ArrowField
+from ._generated.models import CorsRule as GeneratedCorsRule
 from ._generated.models import Logging as GeneratedLogging
 from ._generated.models import Metrics as GeneratedMetrics
 from ._generated.models import RetentionPolicy as GeneratedRetentionPolicy
 from ._generated.models import StaticWebsite as GeneratedStaticWebsite
-from ._generated.models import CorsRule as GeneratedCorsRule
-from ._generated.models import AccessPolicy as GenAccessPolicy
 
 if TYPE_CHECKING:
     from datetime import datetime
+    from ._generated.models import PageList
 
 # Parse a generated PageList into a single list of PageRange sorted by start.
-def parse_page_list(page_list):
+def parse_page_list(page_list: "PageList") -> List["PageRange"]:
 
     page_ranges = page_list.page_range
     clear_ranges = page_list.clear_range
 
+    if page_ranges is None:
+        raise ValueError("PageList's 'page_range' is malformed or None.")
+    if clear_ranges is None:
+        raise ValueError("PageList's 'clear_ranges' is malformed or None.")
+
     ranges = []
     p_i, c_i = 0, 0
 
@@ -42,18 +48,18 @@ def parse_page_list(page_list):
 
         if p.start < c.start:
             ranges.append(
-                PageRange(p.start, p.end, cleared=False)
+                PageRange(start=p.start, end=p.end, cleared=False)
             )
             p_i += 1
         else:
             ranges.append(
-                PageRange(c.start, c.end, cleared=True)
+                PageRange(start=c.start, end=c.end, cleared=True)
             )
             c_i += 1
 
     # Grab remaining elements in either list
-    ranges += [PageRange(r.start, r.end, cleared=False) for r in page_ranges[p_i:]]
-    ranges += [PageRange(r.start, r.end, cleared=True) for r in clear_ranges[c_i:]]
+    ranges += [PageRange(start=r.start, end=r.end, cleared=False) for r in page_ranges[p_i:]]
+    ranges += [PageRange(start=r.start, end=r.end, cleared=True) for r in clear_ranges[c_i:]]
 
     return ranges
 
@@ -168,6 +174,37 @@ class BlobImmutabilityPolicyMode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
     MUTABLE = "Mutable"
 
 
+class RetentionPolicy(GeneratedRetentionPolicy):
+    """The retention policy which determines how long the associated data should
+    persist.
+
+    :param bool enabled:
+        Indicates whether a retention policy is enabled for the storage service.
+        The default value is False.
+    :param Optional[int] days:
+        Indicates the number of days that metrics or logging or
+        soft-deleted data should be retained. All data older than this value will
+        be deleted. If enabled=True, the number of days must be specified.
+    """
+
+    enabled: bool = False
+    days: Optional[int] = None
+
+    def __init__(self, enabled: bool = False, days: Optional[int] = None) -> None:
+        super(RetentionPolicy, self).__init__(enabled=enabled, days=days, allow_permanent_delete=None)
+        if self.enabled and (self.days is None):
+            raise ValueError("If policy is enabled, 'days' must be specified.")
+
+    @classmethod
+    def _from_generated(cls, generated):
+        if not generated:
+            return cls()
+        return cls(
+            enabled=generated.enabled,
+            days=generated.days,
+        )
+
+
 class BlobAnalyticsLogging(GeneratedLogging):
     """Azure Analytics Logging settings.
 
@@ -184,7 +221,18 @@ class BlobAnalyticsLogging(GeneratedLogging):
         policy will be disabled by default.
     """
 
-    def __init__(self, **kwargs):
+    version: str = '1.0'
+    """The version of Storage Analytics to configure."""
+    delete: bool = False
+    """Indicates whether all delete requests should be logged."""
+    read: bool = False
+    """Indicates whether all read requests should be logged."""
+    write: bool = False
+    """Indicates whether all write requests should be logged."""
+    retention_policy: RetentionPolicy = RetentionPolicy()
+    """Determines how long the associated data should persist."""
+
+    def __init__(self, **kwargs: Any) -> None:
         self.version = kwargs.get('version', '1.0')
         self.delete = kwargs.get('delete', False)
         self.read = kwargs.get('read', False)
@@ -220,7 +268,16 @@ class Metrics(GeneratedMetrics):
         policy will be disabled by default.
     """
 
-    def __init__(self, **kwargs):
+    version: str = '1.0'
+    """The version of Storage Analytics to configure."""
+    enabled: bool = False
+    """Indicates whether metrics are enabled for the Blob service."""
+    include_apis: Optional[bool]
+    """Indicates whether metrics should generate summary statistics for called API operations."""
+    retention_policy: RetentionPolicy = RetentionPolicy()
+    """Determines how long the associated data should persist."""
+
+    def __init__(self, **kwargs: Any) -> None:
         self.version = kwargs.get('version', '1.0')
         self.enabled = kwargs.get('enabled', False)
         self.include_apis = kwargs.get('include_apis')
@@ -238,34 +295,6 @@ class Metrics(GeneratedMetrics):
         )
 
 
-class RetentionPolicy(GeneratedRetentionPolicy):
-    """The retention policy which determines how long the associated data should
-    persist.
-
-    :param bool enabled:
-        Indicates whether a retention policy is enabled for the storage service.
-        The default value is False.
-    :param int days:
-        Indicates the number of days that metrics or logging or
-        soft-deleted data should be retained. All data older than this value will
-        be deleted. If enabled=True, the number of days must be specified.
-    """
-
-    def __init__(self, enabled=False, days=None):
-        super(RetentionPolicy, self).__init__(enabled=enabled, days=days, allow_permanent_delete=None)
-        if self.enabled and (self.days is None):
-            raise ValueError("If policy is enabled, 'days' must be specified.")
-
-    @classmethod
-    def _from_generated(cls, generated):
-        if not generated:
-            return cls()
-        return cls(
-            enabled=generated.enabled,
-            days=generated.days,
-        )
-
-
 class StaticWebsite(GeneratedStaticWebsite):
     """The properties that enable an account to host a static website.
 
@@ -280,7 +309,16 @@ class StaticWebsite(GeneratedStaticWebsite):
         Absolute path of the default index page.
     """
 
-    def __init__(self, **kwargs):
+    enabled: bool = False
+    """Indicates whether this account is hosting a static website."""
+    index_document: Optional[str]
+    """The default name of the index page under each directory."""
+    error_document404_path: Optional[str]
+    """The absolute path of the custom 404 page."""
+    default_index_document_path: Optional[str]
+    """Absolute path of the default index page."""
+
+    def __init__(self, **kwargs: Any) -> None:
         self.enabled = kwargs.get('enabled', False)
         if self.enabled:
             self.index_document = kwargs.get('index_document')
@@ -331,13 +369,45 @@ class CorsRule(GeneratedCorsRule):
         preflight response.
     """
 
-    def __init__(self, allowed_origins, allowed_methods, **kwargs):
+    allowed_origins: str
+    """The comma-delimited string representation of the list of origin domains that will be allowed via
+        CORS, or "*" to allow all domains."""
+    allowed_methods: str
+    """The comma-delimited string representation of the list HTTP methods that are allowed to be executed
+        by the origin."""
+    exposed_headers: str
+    """The comma-delimited string representation of the list of response headers to expose to CORS clients."""
+    allowed_headers: str
+    """The comma-delimited string representation of the list of headers allowed to be part of the cross-origin
+        request."""
+    max_age_in_seconds: int
+    """The number of seconds that the client/browser should cache a pre-flight response."""
+
+    def __init__(self, allowed_origins: List[str], allowed_methods: List[str], **kwargs: Any) -> None:
         self.allowed_origins = ','.join(allowed_origins)
         self.allowed_methods = ','.join(allowed_methods)
         self.allowed_headers = ','.join(kwargs.get('allowed_headers', []))
         self.exposed_headers = ','.join(kwargs.get('exposed_headers', []))
         self.max_age_in_seconds = kwargs.get('max_age_in_seconds', 0)
 
+    @staticmethod
+    def _to_generated(rules: Optional[List["CorsRule"]]) -> Optional[List[GeneratedCorsRule]]:
+        if rules is None:
+            return rules
+
+        generated_cors_list = []
+        for cors_rule in rules:
+            generated_cors = GeneratedCorsRule(
+                allowed_origins=cors_rule.allowed_origins,
+                allowed_methods=cors_rule.allowed_methods,
+                allowed_headers=cors_rule.allowed_headers,
+                exposed_headers=cors_rule.exposed_headers,
+                max_age_in_seconds=cors_rule.max_age_in_seconds
+            )
+            generated_cors_list.append(generated_cors)
+
+        return generated_cors_list
+
     @classmethod
     def _from_generated(cls, generated):
         return cls(
@@ -354,52 +424,46 @@ class ContainerProperties(DictMixin):
 
     Returned ``ContainerProperties`` instances expose these values through a
     dictionary interface, for example: ``container_props["last_modified"]``.
-    Additionally, the container name is available as ``container_props["name"]``.
-
-    :ivar str name:
-        Name of the container.
-    :ivar ~datetime.datetime last_modified:
-        A datetime object representing the last time the container was modified.
-    :ivar str etag:
-        The ETag contains a value that you can use to perform operations
-        conditionally.
-    :ivar ~azure.storage.blob.LeaseProperties lease:
-        Stores all the lease information for the container.
-    :ivar str public_access: Specifies whether data in the container may be accessed
-        publicly and the level of access.
-    :ivar bool has_immutability_policy:
-        Represents whether the container has an immutability policy.
-    :ivar bool has_legal_hold:
-        Represents whether the container has a legal hold.
-    :ivar bool immutable_storage_with_versioning_enabled:
-        Represents whether immutable storage with versioning enabled on the container.
-
-        .. versionadded:: 12.10.0
-            This was introduced in API version '2020-10-02'.
-
-    :ivar dict metadata: A dict with name-value pairs to associate with the
-        container as metadata.
-    :ivar ~azure.storage.blob.ContainerEncryptionScope encryption_scope:
-        The default encryption scope configuration for the container.
-    :ivar bool deleted:
-        Whether this container was deleted.
-    :ivar str version:
-        The version of a deleted container.
-    """
+    Additionally, the container name is available as ``container_props["name"]``."""
 
-    def __init__(self, **kwargs):
-        self.name = None
-        self.last_modified = kwargs.get('Last-Modified')
-        self.etag = kwargs.get('ETag')
+    name: str
+    """Name of the container."""
+    last_modified: "datetime"
+    """A datetime object representing the last time the container was modified."""
+    etag: str
+    """The ETag contains a value that you can use to perform operations conditionally."""
+    lease: "LeaseProperties"
+    """Stores all the lease information for the container."""
+    public_access: Optional[str]
+    """Specifies whether data in the container may be accessed publicly and the level of access."""
+    has_immutability_policy: bool
+    """Represents whether the container has an immutability policy."""
+    has_legal_hold: bool
+    """Represents whether the container has a legal hold."""
+    immutable_storage_with_versioning_enabled: bool
+    """Represents whether immutable storage with versioning enabled on the container."""
+    metadata: Dict[str, Any]
+    """A dict with name-value pairs to associate with the container as metadata."""
+    encryption_scope: Optional["ContainerEncryptionScope"]
+    """The default encryption scope configuration for the container."""
+    deleted: Optional[bool]
+    """Whether this container was deleted."""
+    version: Optional[str]
+    """The version of a deleted container."""
+
+    def __init__(self, **kwargs: Any) -> None:
+        self.name = None  # type: ignore [assignment]
+        self.last_modified = kwargs.get('Last-Modified')  # type: ignore [assignment]
+        self.etag = kwargs.get('ETag')  # type: ignore [assignment]
         self.lease = LeaseProperties(**kwargs)
         self.public_access = kwargs.get('x-ms-blob-public-access')
-        self.has_immutability_policy = kwargs.get('x-ms-has-immutability-policy')
+        self.has_immutability_policy = kwargs.get('x-ms-has-immutability-policy')  # type: ignore [assignment]
         self.deleted = None
         self.version = None
-        self.has_legal_hold = kwargs.get('x-ms-has-legal-hold')
-        self.metadata = kwargs.get('metadata')
+        self.has_legal_hold = kwargs.get('x-ms-has-legal-hold')  # type: ignore [assignment]
+        self.metadata = kwargs.get('metadata')  # type: ignore [assignment]
         self.encryption_scope = None
-        self.immutable_storage_with_versioning_enabled = kwargs.get('x-ms-immutable-storage-with-versioning-enabled')  # pylint: disable=name-too-long
+        self.immutable_storage_with_versioning_enabled = kwargs.get('x-ms-immutable-storage-with-versioning-enabled')  # type: ignore [assignment]  # pylint: disable=name-too-long
         default_encryption_scope = kwargs.get('x-ms-default-encryption-scope')
         if default_encryption_scope:
             self.encryption_scope = ContainerEncryptionScope(
@@ -428,24 +492,34 @@ class ContainerProperties(DictMixin):
 class ContainerPropertiesPaged(PageIterator):
     """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 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.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
-        call.
-    :param str continuation_token: An opaque continuation token.
+    :param Optional[int] results_per_page: The maximum number of container names to retrieve per call.
+    :param Optional[str] continuation_token: An opaque continuation token.
     """
-    def __init__(self, command, prefix=None, results_per_page=None, continuation_token=None):
+
+    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."""
+    current_page: List["ContainerProperties"]
+    """The current page of listed results."""
+
+    def __init__(
+        self, command: Callable,
+        prefix: Optional[str] = None,
+        results_per_page: Optional[int] = None,
+        continuation_token: Optional[str] = None
+    ) -> None:
         super(ContainerPropertiesPaged, self).__init__(
             get_next=self._get_next_cb,
             extract_data=self._extract_data_cb,
@@ -498,7 +572,12 @@ class ImmutabilityPolicy(DictMixin):
         "Mutable" can only be returned by service, don't set to "Mutable".
     """
 
-    def __init__(self, **kwargs):
+    expiry_time: Optional["datetime"] = None
+    """Specifies the date time when the blobs immutability policy is set to expire."""
+    policy_mode: Optional[str] = None
+    """Specifies the immutability policy mode to set on the blob."""
+
+    def __init__(self, **kwargs: Any) -> None:
         self.expiry_time = kwargs.pop('expiry_time', None)
         self.policy_mode = kwargs.pop('policy_mode', None)
 
@@ -511,33 +590,32 @@ class ImmutabilityPolicy(DictMixin):
 
 
 class FilteredBlob(DictMixin):
-    """Blob info from a Filter Blobs API call.
-
-    :ivar name: Blob name
-    :type name: str
-    :ivar container_name: Container name.
-    :type container_name: str
-    :ivar tags: Key value pairs of blob tags.
-    :type tags: Dict[str, str]
-    """
-    def __init__(self, **kwargs):
+    """Blob info from a Filter Blobs API call."""
+
+    name: str
+    """Blob name"""
+    container_name: Optional[str]
+    """Container name."""
+    tags: Optional[Dict[str, str]]
+    """Key value pairs of blob tags."""
+
+    def __init__(self, **kwargs: Any) -> None:
         self.name = kwargs.get('name', None)
         self.container_name = kwargs.get('container_name', None)
         self.tags = kwargs.get('tags', None)
 
 
 class LeaseProperties(DictMixin):
-    """Blob Lease Properties.
-
-    :ivar str status:
-        The lease status of the blob. Possible values: locked|unlocked
-    :ivar str state:
-        Lease state of the blob. Possible values: available|leased|expired|breaking|broken
-    :ivar str duration:
-        When a blob is leased, specifies whether the lease is of infinite or fixed duration.
-    """
+    """Blob Lease Properties."""
 
-    def __init__(self, **kwargs):
+    status: str
+    """The lease status of the blob. Possible values: locked|unlocked"""
+    state: str
+    """Lease state of the blob. Possible values: available|leased|expired|breaking|broken"""
+    duration: Optional[str]
+    """When a blob is leased, specifies whether the lease is of infinite or fixed duration."""
+
+    def __init__(self, **kwargs: Any) -> None:
         self.status = get_enum_value(kwargs.get('x-ms-lease-status'))
         self.state = get_enum_value(kwargs.get('x-ms-lease-state'))
         self.duration = get_enum_value(kwargs.get('x-ms-lease-duration'))
@@ -554,33 +632,51 @@ class LeaseProperties(DictMixin):
 class ContentSettings(DictMixin):
     """The content settings of a blob.
 
-    :param str content_type:
+    :param Optional[str] content_type:
         The content type specified for the blob. If no content type was
         specified, the default content type is application/octet-stream.
-    :param str content_encoding:
+    :param Optional[str] content_encoding:
         If the content_encoding has previously been set
         for the blob, that value is stored.
-    :param str content_language:
+    :param Optional[str] content_language:
         If the content_language has previously been set
         for the blob, that value is stored.
-    :param str content_disposition:
+    :param Optional[str] content_disposition:
         content_disposition conveys additional information about how to
         process the response payload, and also can be used to attach
         additional metadata. If content_disposition has previously been set
         for the blob, that value is stored.
-    :param str cache_control:
+    :param Optional[str] cache_control:
         If the cache_control has previously been set for
         the blob, that value is stored.
-    :param bytearray content_md5:
+    :param Optional[bytearray] content_md5:
         If the content_md5 has been set for the blob, this response
         header is stored so that the client can check for message content
         integrity.
     """
 
+    content_type: Optional[str] = None
+    """The content type specified for the blob."""
+    content_encoding: Optional[str] = None
+    """The content encoding specified for the blob."""
+    content_language: Optional[str] = None
+    """The content language specified for the blob."""
+    content_disposition: Optional[str] = None
+    """The content disposition specified for the blob."""
+    cache_control: Optional[str] = None
+    """The cache control specified for the blob."""
+    content_md5: Optional[bytearray] = None
+    """The content md5 specified for the blob."""
+
     def __init__(
-            self, content_type=None, content_encoding=None,
-            content_language=None, content_disposition=None,
-            cache_control=None, content_md5=None, **kwargs):
+        self, content_type: Optional[str] = None,
+        content_encoding: Optional[str] = None,
+        content_language: Optional[str] = None,
+        content_disposition: Optional[str] = None,
+        cache_control: Optional[str] = None,
+        content_md5: Optional[bytearray] = None,
+        **kwargs: Any
+    ) -> None:
 
         self.content_type = content_type or kwargs.get('Content-Type')
         self.content_encoding = content_encoding or kwargs.get('Content-Encoding')
@@ -607,46 +703,42 @@ class CopyProperties(DictMixin):
     These properties will be `None` if this blob has never been the destination
     in a Copy Blob operation, or if this blob has been modified after a concluded
     Copy Blob operation, for example, using Set Blob Properties, Upload Blob, or Commit Block List.
+    """
 
-    :ivar str id:
-        String identifier for the last attempted Copy Blob operation where this blob
-        was the destination blob.
-    :ivar str source:
-        URL up to 2 KB in length that specifies the source blob used in the last attempted
-        Copy Blob operation where this blob was the destination blob.
-    :ivar str status:
-        State of the copy operation identified by Copy ID, with these values:
-            success:
-                Copy completed successfully.
-            pending:
-                Copy is in progress. Check copy_status_description if intermittent,
-                non-fatal errors impede copy progress but don't cause failure.
-            aborted:
-                Copy was ended by Abort Copy Blob.
-            failed:
-                Copy failed. See copy_status_description for failure details.
-    :ivar str progress:
-        Contains the number of bytes copied and the total bytes in the source in the last
+    id: Optional[str]
+    """String identifier for the last attempted Copy Blob operation where this blob
+        was the destination blob."""
+    source: Optional[str]
+    """URL up to 2 KB in length that specifies the source blob used in the last attempted
+        Copy Blob operation where this blob was the destination blob."""
+    status: Optional[str]
+    """State of the copy operation identified by Copy ID, with these values:
+    success: Copy completed successfully.
+    pending: Copy is in progress. Check copy_status_description if intermittent, non-fatal errors impede copy progress
+    but don't cause failure.
+    aborted: Copy was ended by Abort Copy Blob.
+    failed: Copy failed. See copy_status_description for failure details."""
+    progress: Optional[str]
+    """Contains the number of bytes copied and the total bytes in the source in the last
         attempted Copy Blob operation where this blob was the destination blob. Can show
-        between 0 and Content-Length bytes copied.
-    :ivar ~datetime.datetime completion_time:
-        Conclusion time of the last attempted Copy Blob operation where this blob was the
+        between 0 and Content-Length bytes copied."""
+    completion_time: Optional["datetime"]
+    """Conclusion time of the last attempted Copy Blob operation where this blob was the
         destination blob. This value can specify the time of a completed, aborted, or
-        failed copy attempt.
-    :ivar str status_description:
-        Only appears when x-ms-copy-status is failed or pending. Describes cause of fatal
-        or non-fatal copy operation failure.
-    :ivar bool incremental_copy:
-        Copies the snapshot of the source page blob to a destination page blob.
+        failed copy attempt."""
+    status_description: Optional[str]
+    """Only appears when x-ms-copy-status is failed or pending. Describes cause of fatal
+        or non-fatal copy operation failure."""
+    incremental_copy: Optional[bool]
+    """Copies the snapshot of the source page blob to a destination page blob.
         The snapshot is copied such that only the differential changes between
-        the previously copied snapshot are transferred to the destination
-    :ivar ~datetime.datetime destination_snapshot:
-        Included if the blob is incremental copy blob or incremental copy snapshot,
+        the previously copied snapshot are transferred to the destination."""
+    destination_snapshot: Optional["datetime"]
+    """Included if the blob is incremental copy blob or incremental copy snapshot,
         if x-ms-copy-status is success. Snapshot time of the last successful
-        incremental copy snapshot for this blob.
-    """
+        incremental copy snapshot for this blob."""
 
-    def __init__(self, **kwargs):
+    def __init__(self, **kwargs: Any) -> None:
         self.id = kwargs.get('x-ms-copy-id')
         self.source = kwargs.get('x-ms-copy-source')
         self.status = get_enum_value(kwargs.get('x-ms-copy-status'))
@@ -675,16 +767,21 @@ class BlobBlock(DictMixin):
 
     :param str block_id:
         Block id.
-    :param str state:
-        Block state. Possible values: committed|uncommitted
-    :ivar int size:
-        Block size in bytes.
+    :param BlockState state:
+        Block state. Possible values: BlockState.COMMITTED | BlockState.UNCOMMITTED
     """
 
-    def __init__(self, block_id, state=BlockState.Latest):
+    block_id: str
+    """Block id."""
+    state: BlockState
+    """Block state."""
+    size: int
+    """Block size."""
+
+    def __init__(self, block_id: str, state: BlockState = BlockState.LATEST) -> None:
         self.id = block_id
         self.state = state
-        self.size = None
+        self.size = None  # type: ignore [assignment]
 
     @classmethod
     def _from_generated(cls, generated):
@@ -708,11 +805,16 @@ class PageRange(DictMixin):
         Start of page range in bytes.
     :param int end:
         End of page range in bytes.
-    :ivar bool cleared:
-        Whether the range has been cleared.
     """
 
-    def __init__(self, start=None, end=None, *, cleared=False):
+    start: Optional[int] = None
+    """Start of page range in bytes."""
+    end: Optional[int] = None
+    """End of page range in bytes."""
+    cleared: bool
+    """Whether the range has been cleared."""
+
+    def __init__(self, start: Optional[int] = None, end: Optional[int] = None, *, cleared: bool = False) -> None:
         self.start = start
         self.end = end
         self.cleared = cleared
@@ -754,54 +856,6 @@ class PageRangePaged(PageIterator):
         return parse_page_list(response)
 
 
-class AccessPolicy(GenAccessPolicy):
-    """Access Policy class used by the set and get access policy methods in each service.
-
-    A stored access policy can specify the start time, expiry time, and
-    permissions for the Shared Access Signatures with which it's associated.
-    Depending on how you want to control access to your resource, you can
-    specify all of these parameters within the stored access policy, and omit
-    them from the URL for the Shared Access Signature. Doing so permits you to
-    modify the associated signature's behavior at any time, as well as to revoke
-    it. Or you can specify one or more of the access policy parameters within
-    the stored access policy, and the others on the URL. Finally, you can
-    specify all of the parameters on the URL. In this case, you can use the
-    stored access policy to revoke the signature, but not to modify its behavior.
-
-    Together the Shared Access Signature and the stored access policy must
-    include all fields required to authenticate the signature. If any required
-    fields are missing, the request will fail. Likewise, if a field is specified
-    both in the Shared Access Signature URL and in the stored access policy, the
-    request will fail with status code 400 (Bad Request).
-
-    :param permission:
-        The permissions associated with the shared access signature. The
-        user is restricted to operations allowed by the permissions.
-        Required unless an id is given referencing a stored access policy
-        which contains this field. This field must be omitted if it has been
-        specified in an associated stored access policy.
-    :type permission: str or ~azure.storage.blob.ContainerSasPermissions
-    :param expiry:
-        The time at which the shared access signature becomes invalid.
-        Required unless an id is given referencing a stored access policy
-        which contains this field. This field must be omitted if it has
-        been specified in an associated stored access policy. Azure will always
-        convert values to UTC. If a date is passed in without timezone info, it
-        is assumed to be UTC.
-    :type expiry: ~datetime.datetime or str
-    :param start:
-        The time at which the shared access signature becomes valid. If
-        omitted, start time for this call is assumed to be the time when the
-        storage service receives the request. The provided datetime will always
-        be interpreted as UTC.
-    :type start: ~datetime.datetime or str
-    """
-    def __init__(self, permission=None, expiry=None, start=None):
-        self.start = start
-        self.expiry = expiry
-        self.permission = permission
-
-
 class ContainerSasPermissions(object):
     """ContainerSasPermissions class to be used with the
     :func:`~azure.storage.blob.generate_container_sas` function and
@@ -844,8 +898,43 @@ class ContainerSasPermissions(object):
         To enable operations related to set/delete immutability policy.
         To get immutability policy, you just need read permission.
     """
-    def __init__(self, read=False, write=False, delete=False,
-                 list=False, delete_previous_version=False, tag=False, **kwargs):  # pylint: disable=redefined-builtin
+
+    read: bool = False
+    """The read permission for container SAS."""
+    write: bool = False
+    """The write permission for container SAS."""
+    delete: bool = False
+    """The delete permission for container SAS."""
+    delete_previous_version: bool = False
+    """Permission to delete previous blob version for versioning enabled
+        storage accounts."""
+    list: bool = False
+    """The list permission for container SAS."""
+    tag: bool = False
+    """Set or get tags on the blobs in the container."""
+    add: Optional[bool]
+    """Add a block to an append blob."""
+    create: Optional[bool]
+    """Write a new blob, snapshot a blob, or copy a blob to a new blob."""
+    permanent_delete: Optional[bool]
+    """To enable permanent delete on the blob is permitted."""
+    move: Optional[bool]
+    """Move a blob or a directory and its contents to a new location."""
+    execute: Optional[bool]
+    """Get the system properties and, if the hierarchical namespace is enabled for the storage account,
+        get the POSIX ACL of a blob."""
+    set_immutability_policy: Optional[bool]
+    """To get immutability policy, you just need read permission."""
+
+    def __init__(
+        self, read: bool = False,
+        write: bool = False,
+        delete: bool = False,
+        list: bool = False,
+        delete_previous_version: bool = False,
+        tag: bool = False,
+        **kwargs: Any
+    ) -> None:  # pylint: disable=redefined-builtin
         self.read = read
         self.add = kwargs.pop('add', False)
         self.create = kwargs.pop('create', False)
@@ -877,7 +966,7 @@ class ContainerSasPermissions(object):
         return self._str
 
     @classmethod
-    def from_string(cls, permission):
+    def from_string(cls, permission: str) -> "ContainerSasPermissions":
         """Create a ContainerSasPermissions from a string.
 
         To specify read, write, delete, or list permissions you need only to
@@ -910,6 +999,68 @@ class ContainerSasPermissions(object):
         return parsed
 
 
+class AccessPolicy(GenAccessPolicy):
+    """Access Policy class used by the set and get access policy methods in each service.
+
+    A stored access policy can specify the start time, expiry time, and
+    permissions for the Shared Access Signatures with which it's associated.
+    Depending on how you want to control access to your resource, you can
+    specify all of these parameters within the stored access policy, and omit
+    them from the URL for the Shared Access Signature. Doing so permits you to
+    modify the associated signature's behavior at any time, as well as to revoke
+    it. Or you can specify one or more of the access policy parameters within
+    the stored access policy, and the others on the URL. Finally, you can
+    specify all of the parameters on the URL. In this case, you can use the
+    stored access policy to revoke the signature, but not to modify its behavior.
+
+    Together the Shared Access Signature and the stored access policy must
+    include all fields required to authenticate the signature. If any required
+    fields are missing, the request will fail. Likewise, if a field is specified
+    both in the Shared Access Signature URL and in the stored access policy, the
+    request will fail with status code 400 (Bad Request).
+
+    :param permission:
+        The permissions associated with the shared access signature. The
+        user is restricted to operations allowed by the permissions.
+        Required unless an id is given referencing a stored access policy
+        which contains this field. This field must be omitted if it has been
+        specified in an associated stored access policy.
+    :type permission: Optional[Union[ContainerSasPermissions, str]]
+    :param expiry:
+        The time at which the shared access signature becomes invalid.
+        Required unless an id is given referencing a stored access policy
+        which contains this field. This field must be omitted if it has
+        been specified in an associated stored access policy. Azure will always
+        convert values to UTC. If a date is passed in without timezone info, it
+        is assumed to be UTC.
+    :paramtype expiry: Optional[Union[str, datetime]]
+    :param start:
+        The time at which the shared access signature becomes valid. If
+        omitted, start time for this call is assumed to be the time when the
+        storage service receives the request. Azure will always convert values
+        to UTC. If a date is passed in without timezone info, it is assumed to
+        be UTC.
+    :paramtype start: Optional[Union[str, datetime]]
+    """
+
+    permission: Optional[Union[ContainerSasPermissions, str]]  # type: ignore [assignment]
+    """The permissions associated with the shared access signature. The user is restricted to
+        operations allowed by the permissions."""
+    expiry: Optional[Union["datetime", str]]  # type: ignore [assignment]
+    """The time at which the shared access signature becomes invalid."""
+    start: Optional[Union["datetime", str]]  # type: ignore [assignment]
+    """The time at which the shared access signature becomes valid."""
+
+    def __init__(
+        self, permission: Optional[Union["ContainerSasPermissions", str]] = None,
+        expiry: Optional[Union[str, "datetime"]] = None,
+        start: Optional[Union[str, "datetime"]] = None
+    ) -> None:
+        self.start = start
+        self.expiry = expiry
+        self.permission = permission
+
+
 class BlobSasPermissions(object):
     """BlobSasPermissions class to be used with the
     :func:`~azure.storage.blob.generate_blob_sas` function.
@@ -942,8 +1093,42 @@ class BlobSasPermissions(object):
         To enable operations related to set/delete immutability policy.
         To get immutability policy, you just need read permission.
     """
-    def __init__(self, read=False, add=False, create=False, write=False,
-                 delete=False, delete_previous_version=False, tag=False, **kwargs):
+
+    read: bool = False
+    """The read permission for Blob SAS."""
+    add: Optional[bool]
+    """The add permission for Blob SAS."""
+    create: Optional[bool]
+    """Write a new blob, snapshot a blob, or copy a blob to a new blob."""
+    write: bool = False
+    """The write permission for Blob SAS."""
+    delete: bool = False
+    """The delete permission for Blob SAS."""
+    delete_previous_version: bool = False
+    """Permission to delete previous blob version for versioning enabled
+        storage accounts."""
+    tag: bool = False
+    """Set or get tags on the blobs in the Blob."""
+    permanent_delete: Optional[bool]
+    """To enable permanent delete on the blob is permitted."""
+    move: Optional[bool]
+    """Move a blob or a directory and its contents to a new location."""
+    execute: Optional[bool]
+    """Get the system properties and, if the hierarchical namespace is enabled for the storage account,
+        get the POSIX ACL of a blob."""
+    set_immutability_policy: Optional[bool]
+    """To get immutability policy, you just need read permission."""
+
+    def __init__(
+        self, read: bool = False,
+        add: bool = False,
+        create: bool = False,
+        write: bool = False,
+        delete: bool = False,
+        delete_previous_version: bool = False,
+        tag: bool = False,
+        **kwargs: Any
+    ) -> None:
         self.read = read
         self.add = add
         self.create = create
@@ -971,7 +1156,7 @@ class BlobSasPermissions(object):
         return self._str
 
     @classmethod
-    def from_string(cls, permission):
+    def from_string(cls, permission: str) -> "BlobSasPermissions":
         """Create a BlobSasPermissions from a string.
 
         To specify read, add, create, write, or delete permissions you need only to
@@ -1021,10 +1206,16 @@ class CustomerProvidedEncryptionKey(object):
         Base64-encoded AES-256 encryption key value.
     :param str key_hash:
         Base64-encoded SHA256 of the encryption key.
-    :ivar str algorithm:
-        Specifies the algorithm to use when encrypting data using the given key. Must be AES256.
     """
-    def __init__(self, key_value, key_hash):
+
+    key_value: str
+    """Base64-encoded AES-256 encryption key value."""
+    key_hash: str
+    """Base64-encoded SHA256 of the encryption key."""
+    algorithm: str
+    """Specifies the algorithm to use when encrypting data using the given key. Must be AES256."""
+
+    def __init__(self, key_value: str, key_hash: str) -> None:
         self.key_value = key_value
         self.key_hash = key_hash
         self.algorithm = 'AES256'
@@ -1046,7 +1237,14 @@ class ContainerEncryptionScope(object):
         set on the container. Default value is false.
     """
 
-    def __init__(self, default_encryption_scope, **kwargs):
+    default_encryption_scope: str
+    """Specifies the default encryption scope to set on the container and use for
+        all future writes."""
+    prevent_encryption_scope_override: bool
+    """If true, prevents any request from specifying a different encryption scope than the scope
+        set on the container."""
+
+    def __init__(self, default_encryption_scope: str, **kwargs: Any) -> None:
         self.default_encryption_scope = default_encryption_scope
         self.prevent_encryption_scope_override = kwargs.get('prevent_encryption_scope_override', False)
 
@@ -1064,10 +1262,10 @@ class ContainerEncryptionScope(object):
 class DelimitedJsonDialect(DictMixin):
     """Defines the input or output JSON serialization for a blob data query.
 
-    :keyword str delimiter: The line separator character, default value is '\n'
+    :keyword str delimiter: The line separator character, default value is '\\\\n'.
     """
 
-    def __init__(self, **kwargs):
+    def __init__(self, **kwargs: Any) -> None:
         self.delimiter = kwargs.pop('delimiter', '\n')
 
 
@@ -1087,7 +1285,8 @@ class DelimitedTextDialect(DictMixin):
         data will be returned inclusive of the first line. If set to True, the data will be returned exclusive
         of the first line.
     """
-    def __init__(self, **kwargs):
+
+    def __init__(self, **kwargs: Any) -> None:
         self.delimiter = kwargs.pop('delimiter', ',')
         self.quotechar = kwargs.pop('quotechar', '"')
         self.lineterminator = kwargs.pop('lineterminator', '\n')
@@ -1105,7 +1304,8 @@ class ArrowDialect(ArrowField):
     :keyword int precision: The precision of the field.
     :keyword int scale: The scale of the field.
     """
-    def __init__(self, type, **kwargs):   # pylint: disable=redefined-builtin
+
+    def __init__(self, type, **kwargs: Any) -> None:   # pylint: disable=redefined-builtin
         super(ArrowDialect, self).__init__(type=type, **kwargs)
 
 
@@ -1119,19 +1319,31 @@ class ArrowType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
     DECIMAL = 'decimal'
 
 
+class ObjectReplicationRule(DictMixin):
+    """Policy id and rule ids applied to a blob."""
+
+    rule_id: str
+    """Rule id."""
+    status: str
+    """The status of the rule. It could be "Complete" or "Failed" """
+
+    def __init__(self, **kwargs: Any) -> None:
+        self.rule_id = kwargs.pop('rule_id', None)  # type: ignore [assignment]
+        self.status = kwargs.pop('status', None)  # type: ignore [assignment]
+
+
 class ObjectReplicationPolicy(DictMixin):
-    """Policy id and rule ids applied to a blob.
+    """Policy id and rule ids applied to a blob."""
 
-    :ivar str policy_id:
-        Policy id for the blob. A replication policy gets created (policy id) when creating a source/destination pair.
-    :ivar list(~azure.storage.blob.ObjectReplicationRule) rules:
-        Within each policy there may be multiple replication rules.
-        e.g. rule 1= src/container/.pdf to dst/container2/; rule2 = src/container1/.jpg to dst/container3
-    """
+    policy_id: str
+    """Policy id for the blob. A replication policy gets created (policy id) when creating a source/destination pair."""
+    rules: List[ObjectReplicationRule]
+    """Within each policy there may be multiple replication rules.
+        e.g. rule 1= src/container/.pdf to dst/container2/; rule2 = src/container1/.jpg to dst/container3"""
 
-    def __init__(self, **kwargs):
-        self.policy_id = kwargs.pop('policy_id', None)
-        self.rules = kwargs.pop('rules', None)
+    def __init__(self, **kwargs: Any) -> None:
+        self.policy_id = kwargs.pop('policy_id', None)  # type: ignore [assignment]
+        self.rules = kwargs.pop('rules', [])
 
 
 class BlobProperties(DictMixin):
@@ -1225,23 +1437,23 @@ class BlobProperties(DictMixin):
     """Specified if a legal hold should be set on the blob.
         Currently this parameter of upload_blob() API is for BlockBlob only."""
 
-    def __init__(self, **kwargs):
-        self.name = kwargs.get('name')
-        self.container = None
+    def __init__(self, **kwargs: Any) -> None:
+        self.name = kwargs.get('name')  # type: ignore [assignment]
+        self.container = None  # type: ignore [assignment]
         self.snapshot = kwargs.get('x-ms-snapshot')
         self.version_id = kwargs.get('x-ms-version-id')
         self.is_current_version = kwargs.get('x-ms-is-current-version')
-        self.blob_type = BlobType(kwargs['x-ms-blob-type']) if kwargs.get('x-ms-blob-type') else None
-        self.metadata = kwargs.get('metadata')
+        self.blob_type = BlobType(kwargs['x-ms-blob-type']) if kwargs.get('x-ms-blob-type') else None  # type: ignore [assignment] # pylint: disable=line-too-long
+        self.metadata = kwargs.get('metadata')  # type: ignore [assignment]
         self.encrypted_metadata = kwargs.get('encrypted_metadata')
-        self.last_modified = kwargs.get('Last-Modified')
-        self.etag = kwargs.get('ETag')
-        self.size = kwargs.get('Content-Length')
+        self.last_modified = kwargs.get('Last-Modified')  # type: ignore [assignment]
+        self.etag = kwargs.get('ETag')  # type: ignore [assignment]
+        self.size = kwargs.get('Content-Length')  # type: ignore [assignment]
         self.content_range = kwargs.get('Content-Range')
         self.append_blob_committed_block_count = kwargs.get('x-ms-blob-committed-block-count')
         self.is_append_blob_sealed = kwargs.get('x-ms-blob-sealed')
         self.page_blob_sequence_number = kwargs.get('x-ms-blob-sequence-number')
-        self.server_encrypted = kwargs.get('x-ms-server-encrypted')
+        self.server_encrypted = kwargs.get('x-ms-server-encrypted')  # type: ignore [assignment]
         self.copy = CopyProperties(**kwargs)
         self.content_settings = ContentSettings(**kwargs)
         self.lease = LeaseProperties(**kwargs)
@@ -1252,7 +1464,7 @@ class BlobProperties(DictMixin):
         self.deleted = False
         self.deleted_time = None
         self.remaining_retention_days = None
-        self.creation_time = kwargs.get('x-ms-creation-time')
+        self.creation_time = kwargs.get('x-ms-creation-time')  # type: ignore [assignment]
         self.archive_status = kwargs.get('x-ms-archive-status')
         self.encryption_key_sha256 = kwargs.get('x-ms-encryption-key-sha256')
         self.encryption_scope = kwargs.get('x-ms-encryption-scope')
@@ -1268,35 +1480,26 @@ class BlobProperties(DictMixin):
         self.has_versions_only = None
 
 
-class ObjectReplicationRule(DictMixin):
-    """Policy id and rule ids applied to a blob.
-
-    :ivar str rule_id:
-        Rule id.
-    :ivar str status:
-        The status of the rule. It could be "Complete" or "Failed"
-    """
-
-    def __init__(self, **kwargs):
-        self.rule_id = kwargs.pop('rule_id', None)
-        self.status = kwargs.pop('status', None)
-
-
 class BlobQueryError(object):
-    """The error happened during quick query operation.
+    """The error happened during quick query operation."""
 
-    :ivar str error:
-        The name of the error.
-    :ivar bool is_fatal:
-        If true, this error prevents further query processing. More result data may be returned,
+    error: Optional[str]
+    """The name of the error."""
+    is_fatal: bool
+    """If true, this error prevents further query processing. More result data may be returned,
         but there is no guarantee that all of the original data will be processed.
-        If false, this error does not prevent further query processing.
-    :ivar str description:
-        A description of the error.
-    :ivar int position:
-        The blob offset at which the error occurred.
-    """
-    def __init__(self, error=None, is_fatal=False, description=None, position=None):
+        If false, this error does not prevent further query processing."""
+    description: Optional[str]
+    """A description of the error."""
+    position: Optional[int]
+    """The blob offset at which the error occurred."""
+
+    def __init__(
+        self, error: Optional[str] = None,
+        is_fatal: bool = False,
+        description: Optional[str] = None,
+        position: Optional[int] = None
+    ) -> None:
         self.error = error
         self.is_fatal = is_fatal
         self.description = description