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

azure/storage/blob/_quick_query_helper.py

@@ -5,37 +5,39 @@
 # --------------------------------------------------------------------------
 
 from io import BytesIO
-from typing import Union, Iterable, IO  # pylint: disable=unused-import
+from typing import Any, Dict, Generator, IO, Iterable, Optional, Type, Union, TYPE_CHECKING
 
-from ._shared.avro.datafile import DataFileReader
 from ._shared.avro.avro_io import DatumReader
+from ._shared.avro.datafile import DataFileReader
+
+if TYPE_CHECKING:
+    from ._models import BlobQueryError
 
 
 class BlobQueryReader(object):  # pylint: disable=too-many-instance-attributes
-    """A streaming object to read query results.
-
-    :ivar str name:
-        The name of the blob being quered.
-    :ivar str container:
-        The name of the container where the blob is.
-    :ivar dict response_headers:
-        The response_headers of the quick query request.
-    :ivar bytes record_delimiter:
-        The delimiter used to separate lines, or records with the data. The `records`
-        method will return these lines via a generator.
-    """
+    """A streaming object to read query results."""
+
+    name: str
+    """The name of the blob being quered."""
+    container: str
+    """The name of the container where the blob is."""
+    response_headers: Dict[str, Any]
+    """The response_headers of the quick query request."""
+    record_delimiter: str
+    """The delimiter used to separate lines, or records with the data. The `records`
+    method will return these lines via a generator."""
 
     def __init__(
         self,
-        name=None,
-        container=None,
-        errors=None,
-        record_delimiter='\n',
-        encoding=None,
-        headers=None,
-        response=None,
-        error_cls=None,
-    ):
+        name: str = None,  # type: ignore [assignment]
+        container: str = None,  # type: ignore [assignment]
+        errors: Any = None,
+        record_delimiter: str = '\n',
+        encoding: Optional[str] = None,
+        headers: Dict[str, Any] = None,  # type: ignore [assignment]
+        response: Any = None,
+        error_cls: Type["BlobQueryError"] = None,  # type: ignore [assignment]
+    ) -> None:
         self.name = name
         self.container = container
         self.response_headers = headers
@@ -51,7 +53,7 @@ class BlobQueryReader(object):  # pylint: disable=too-many-instance-attributes
     def __len__(self):
         return self._size
 
-    def _process_record(self, result):
+    def _process_record(self, result: Dict[str, Any]) -> Optional[bytes]:
         self._size = result.get('totalBytes', self._size)
         self._bytes_processed = result.get('bytesScanned', self._bytes_processed)
         if 'data' in result:
@@ -67,7 +69,7 @@ class BlobQueryReader(object):  # pylint: disable=too-many-instance-attributes
                 self._errors(error)
         return None
 
-    def _iter_stream(self):
+    def _iter_stream(self) -> Generator[bytes, None, None]:
         if self._first_result is not None:
             yield self._first_result
         for next_result in self._parsed_results:
@@ -75,8 +77,7 @@ class BlobQueryReader(object):  # pylint: disable=too-many-instance-attributes
             if processed_result is not None:
                 yield processed_result
 
-    def readall(self):
-        # type: () -> Union[bytes, str]
+    def readall(self) -> Union[bytes, str]:
         """Return all query results.
 
         This operation is blocking until all data is downloaded.
@@ -93,8 +94,7 @@ class BlobQueryReader(object):  # pylint: disable=too-many-instance-attributes
             return data.decode(self._encoding)
         return data
 
-    def readinto(self, stream):
-        # type: (IO) -> None
+    def readinto(self, stream: IO) -> None:
         """Download the query result to a stream.
 
         :param IO stream:
@@ -105,8 +105,7 @@ class BlobQueryReader(object):  # pylint: disable=too-many-instance-attributes
         for record in self._iter_stream():
             stream.write(record)
 
-    def records(self):
-        # type: () -> Iterable[Union[bytes, str]]
+    def records(self) -> Iterable[Union[bytes, str]]:
         """Returns a record generator for the query result.
 
         Records will be returned line by line.

azure/storage/blob/_serialize.py

@@ -3,9 +3,7 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import (  # pylint: disable=unused-import
-    Any, Dict, Optional, Tuple, Union,
-    TYPE_CHECKING)
+from typing import Any, cast, Dict, Optional, Tuple, Union, TYPE_CHECKING
 
 try:
     from urllib.parse import quote
@@ -14,23 +12,22 @@ except ImportError:
 
 from azure.core import MatchConditions
 
-from ._models import (
-    ContainerEncryptionScope,
-    DelimitedJsonDialect)
 from ._generated.models import (
-    ModifiedAccessConditions,
-    SourceModifiedAccessConditions,
-    CpkScopeInfo,
+    ArrowConfiguration,
+    BlobTag,
+    BlobTags,
     ContainerCpkScopeInfo,
-    QueryFormat,
-    QuerySerialization,
+    CpkScopeInfo,
     DelimitedTextConfiguration,
     JsonTextConfiguration,
-    ArrowConfiguration,
+    LeaseAccessConditions,
+    ModifiedAccessConditions,
+    QueryFormat,
     QueryFormatType,
-    BlobTag,
-    BlobTags, LeaseAccessConditions
+    QuerySerialization,
+    SourceModifiedAccessConditions
 )
+from ._models import ContainerEncryptionScope, DelimitedJsonDialect
 
 if TYPE_CHECKING:
     from ._lease import BlobLeaseClient
@@ -62,8 +59,11 @@ _SUPPORTED_API_VERSIONS = [
 ]
 
 
-def _get_match_headers(kwargs, match_param, etag_param):
-    # type: (Dict[str, Any], str, str) -> Tuple(Dict[str, Any], Optional[str], Optional[str])
+def _get_match_headers(
+    kwargs: Dict[str, Any],
+    match_param: str,
+    etag_param: str
+) -> Tuple[Optional[str], Optional[Any]]:
     if_match = None
     if_none_match = None
     match_condition = kwargs.pop(match_param, None)
@@ -87,8 +87,7 @@ def _get_match_headers(kwargs, match_param, etag_param):
     return if_match, if_none_match
 
 
-def get_access_conditions(lease):
-    # type: (Optional[Union[BlobLeaseClient, str]]) -> Union[LeaseAccessConditions, None]
+def get_access_conditions(lease: Optional[Union["BlobLeaseClient", str]]) -> Optional[LeaseAccessConditions]:
     try:
         lease_id = lease.id # type: ignore
     except AttributeError:
@@ -96,8 +95,7 @@ def get_access_conditions(lease):
     return LeaseAccessConditions(lease_id=lease_id) if lease_id else None
 
 
-def get_modify_conditions(kwargs):
-    # type: (Dict[str, Any]) -> ModifiedAccessConditions
+def get_modify_conditions(kwargs: Dict[str, Any]) -> ModifiedAccessConditions:
     if_match, if_none_match = _get_match_headers(kwargs, 'match_condition', 'etag')
     return ModifiedAccessConditions(
         if_modified_since=kwargs.pop('if_modified_since', None),
@@ -108,8 +106,7 @@ def get_modify_conditions(kwargs):
     )
 
 
-def get_source_conditions(kwargs):
-    # type: (Dict[str, Any]) -> SourceModifiedAccessConditions
+def get_source_conditions(kwargs: Dict[str, Any]) -> SourceModifiedAccessConditions:
     if_match, if_none_match = _get_match_headers(kwargs, 'source_match_condition', 'source_etag')
     return SourceModifiedAccessConditions(
         source_if_modified_since=kwargs.pop('source_if_modified_since', None),
@@ -120,15 +117,13 @@ def get_source_conditions(kwargs):
     )
 
 
-def get_cpk_scope_info(kwargs):
-    # type: (Dict[str, Any]) -> CpkScopeInfo
+def get_cpk_scope_info(kwargs: Dict[str, Any]) -> Optional[CpkScopeInfo]:
     if 'encryption_scope' in kwargs:
         return CpkScopeInfo(encryption_scope=kwargs.pop('encryption_scope'))
     return None
 
 
-def get_container_cpk_scope_info(kwargs):
-    # type: (Dict[str, Any]) -> ContainerCpkScopeInfo
+def get_container_cpk_scope_info(kwargs: Dict[str, Any]) -> Optional[ContainerCpkScopeInfo]:
     encryption_scope = kwargs.pop('container_encryption_scope', None)
     if encryption_scope:
         if isinstance(encryption_scope, ContainerEncryptionScope):
@@ -145,22 +140,19 @@ def get_container_cpk_scope_info(kwargs):
     return None
 
 
-def get_api_version(kwargs):
-    # type: (Dict[str, Any]) -> str
+def get_api_version(kwargs: Dict[str, Any]) -> str:
     api_version = kwargs.get('api_version', None)
     if api_version and api_version not in _SUPPORTED_API_VERSIONS:
         versions = '\n'.join(_SUPPORTED_API_VERSIONS)
         raise ValueError(f"Unsupported API version '{api_version}'. Please select from:\n{versions}")
     return api_version or _SUPPORTED_API_VERSIONS[-1]
 
-def get_version_id(self_vid, kwargs):
-    # type: (Optional[str], Dict[str, Any]) -> Optional[str]
+def get_version_id(self_vid: Optional[str], kwargs: Dict[str, Any]) -> Optional[str]:
     if 'version_id' in kwargs:
-        return kwargs.pop('version_id')
+        return cast(str, kwargs.pop('version_id'))
     return self_vid
 
-def serialize_blob_tags_header(tags=None):
-    # type: (Optional[Dict[str, str]]) -> str
+def serialize_blob_tags_header(tags: Optional[Dict[str, str]] = None) -> Optional[str]:
     if tags is None:
         return None
 
@@ -178,33 +170,27 @@ def serialize_blob_tags_header(tags=None):
     return ''.join(components)
 
 
-def serialize_blob_tags(tags=None):
-    # type: (Optional[Dict[str, str]]) -> Union[BlobTags, None]
+def serialize_blob_tags(tags: Optional[Dict[str, str]] = None) -> BlobTags:
     tag_list = []
     if tags:
         tag_list = [BlobTag(key=k, value=v) for k, v in tags.items()]
     return BlobTags(blob_tag_set=tag_list)
 
 
-def serialize_query_format(formater):
+def serialize_query_format(formater: Union[str, DelimitedJsonDialect]) -> Optional[QuerySerialization]:
     if formater == "ParquetDialect":
-        qq_format = QueryFormat(
-            type=QueryFormatType.PARQUET,
-            parquet_text_configuration=' '
-        )
+        qq_format = QueryFormat(type=QueryFormatType.PARQUET, parquet_text_configuration=' ')  #type: ignore [arg-type]
     elif isinstance(formater, DelimitedJsonDialect):
-        serialization_settings = JsonTextConfiguration(
-            record_separator=formater.delimiter
-        )
-        qq_format = QueryFormat(
-            type=QueryFormatType.json,
-            json_text_configuration=serialization_settings)
+        json_serialization_settings = JsonTextConfiguration(record_separator=formater.delimiter)
+        qq_format = QueryFormat(type=QueryFormatType.JSON, json_text_configuration=json_serialization_settings)
     elif hasattr(formater, 'quotechar'):  # This supports a csv.Dialect as well
         try:
-            headers = formater.has_header
+            headers = formater.has_header  # type: ignore
         except AttributeError:
             headers = False
-        serialization_settings = DelimitedTextConfiguration(
+        if isinstance(formater, str):
+            raise ValueError("Unknown string value provided. Accepted values: ParquetDialect")
+        csv_serialization_settings = DelimitedTextConfiguration(
             column_separator=formater.delimiter,
             field_quote=formater.quotechar,
             record_separator=formater.lineterminator,
@@ -212,16 +198,12 @@ def serialize_query_format(formater):
             headers_present=headers
         )
         qq_format = QueryFormat(
-            type=QueryFormatType.delimited,
-            delimited_text_configuration=serialization_settings
+            type=QueryFormatType.DELIMITED,
+            delimited_text_configuration=csv_serialization_settings
         )
     elif isinstance(formater, list):
-        serialization_settings = ArrowConfiguration(
-            schema=formater
-        )
-        qq_format = QueryFormat(
-            type=QueryFormatType.arrow,
-            arrow_configuration=serialization_settings)
+        arrow_serialization_settings = ArrowConfiguration(schema=formater)
+        qq_format = QueryFormat(type=QueryFormatType.arrow, arrow_configuration=arrow_serialization_settings)
     elif not formater:
         return None
     else:

azure/storage/blob/_shared/avro/datafile.py

@@ -185,7 +185,7 @@ class DataFileReader(object):  # pylint: disable=too-many-instance-attributes
 
         # check magic number
         if header.get('magic') != MAGIC:
-            fail_msg = f"Not an Avro data file: {header.get('magic')} doesn't match {MAGIC}."
+            fail_msg = f"Not an Avro data file: {header.get('magic')} doesn't match {MAGIC!r}."
             raise schema.AvroException(fail_msg)
 
         # set metadata

azure/storage/blob/_shared/avro/datafile_async.py

@@ -146,7 +146,7 @@ class AsyncDataFileReader(object):  # pylint: disable=too-many-instance-attribut
 
         # check magic number
         if header.get('magic') != MAGIC:
-            fail_msg = f"Not an Avro data file: {header.get('magic')} doesn't match {MAGIC}."
+            fail_msg = f"Not an Avro data file: {header.get('magic')} doesn't match {MAGIC!r}."
             raise schema.AvroException(fail_msg)
 
         # set metadata

azure/storage/blob/_shared/base_client.py

@@ -331,7 +331,7 @@ class StorageAccountHostsMixin(object):  # pylint: disable=too-many-instance-att
                     )
                     raise error
                 return iter(parts)
-            return parts
+            return parts  # type: ignore [no-any-return]
         except HttpResponseError as error:
             process_storage_error(error)
 

azure/storage/blob/_shared/base_client_async.py

@@ -201,7 +201,7 @@ class AsyncStorageAccountHostsMixin(object):
                     )
                     raise error
                 return AsyncList(parts_list)
-            return parts
+            return parts  # type: ignore [no-any-return]
         except HttpResponseError as error:
             process_storage_error(error)
 

azure/storage/blob/_shared/policies.py

@@ -14,10 +14,10 @@ from io import SEEK_SET, UnsupportedOperation
 from time import time
 from typing import Any, Dict, Optional, TYPE_CHECKING
 from urllib.parse import (
-        parse_qsl,
-        urlencode,
-        urlparse,
-        urlunparse,
+    parse_qsl,
+    urlencode,
+    urlparse,
+    urlunparse,
 )
 from wsgiref.handlers import format_date_time
 
@@ -28,10 +28,10 @@ from azure.core.pipeline.policies import (
     HTTPPolicy,
     NetworkTraceLoggingPolicy,
     RequestHistory,
-    SansIOHTTPPolicy,
+    SansIOHTTPPolicy
 )
 
-from .authentication import StorageHttpChallenge
+from .authentication import AzureSigningError, StorageHttpChallenge
 from .constants import DEFAULT_OAUTH_SCOPE
 from .models import LocationMode
 
@@ -542,6 +542,8 @@ class StorageRetryPolicy(HTTPPolicy):
                         continue
                 break
             except AzureError as err:
+                if isinstance(err, AzureSigningError):
+                    raise
                 retries_remaining = self.increment(
                     retry_settings, request=request.http_request, error=err)
                 if retries_remaining:

azure/storage/blob/_shared/policies_async.py

@@ -13,7 +13,7 @@ from typing import Any, Dict, TYPE_CHECKING
 from azure.core.exceptions import AzureError
 from azure.core.pipeline.policies import AsyncBearerTokenCredentialPolicy, AsyncHTTPPolicy
 
-from .authentication import StorageHttpChallenge
+from .authentication import AzureSigningError, StorageHttpChallenge
 from .constants import DEFAULT_OAUTH_SCOPE
 from .policies import is_retry, StorageRetryPolicy
 
@@ -127,6 +127,8 @@ class AsyncStorageRetryPolicy(StorageRetryPolicy):
                         continue
                 break
             except AzureError as err:
+                if isinstance(err, AzureSigningError):
+                    raise
                 retries_remaining = self.increment(
                     retry_settings, request=request.http_request, error=err)
                 if retries_remaining:

azure/storage/blob/_shared/response_handlers.py

@@ -17,7 +17,8 @@ from azure.core.exceptions import (
 )
 from azure.core.pipeline.policies import ContentDecodePolicy
 
-from .models import StorageErrorCode, UserDelegationKey, get_enum_value
+from .authentication import AzureSigningError
+from .models import get_enum_value, StorageErrorCode, UserDelegationKey
 from .parser import _to_utc_datetime
 
 
@@ -81,9 +82,12 @@ def return_raw_deserialized(response, *_):
     return response.http_response.location_mode, response.context[ContentDecodePolicy.CONTEXT_NAME]
 
 
-def process_storage_error(storage_error) -> NoReturn: # type: ignore [misc] # pylint:disable=too-many-statements
+def process_storage_error(storage_error) -> NoReturn: # type: ignore [misc] # pylint:disable=too-many-statements, too-many-branches
     raise_error = HttpResponseError
     serialized = False
+    if isinstance(storage_error, AzureSigningError):
+        storage_error.message = storage_error.message + \
+            '. This is likely due to an invalid shared key. Please check your shared key and try again.'
     if not storage_error.response or storage_error.response.status_code in [200, 204]:
         raise storage_error
     # If it is one of those three then it has been serialized prior by the generated layer.

azure/storage/blob/_shared/shared_access_signature.py

@@ -108,7 +108,7 @@ class SharedAccessSignature(object):
         self.x_ms_version = x_ms_version
 
     def generate_account(self, services, resource_types, permission, expiry, start=None,
-                         ip=None, protocol=None, **kwargs):
+                         ip=None, protocol=None, **kwargs) -> str:
         '''
         Generates a shared access signature for the account.
         Use the returned signature with the sas_token parameter of the service
@@ -230,5 +230,5 @@ class _SharedAccessHelper(object):
         self._add_query(QueryStringConstants.SIGNED_SIGNATURE,
                         sign_string(account_key, string_to_sign))
 
-    def get_token(self):
+    def get_token(self) -> str:
         return '&'.join([f'{n}={url_quote(v)}' for n, v in self.query_dict.items() if v is not None])

azure/storage/blob/_shared/uploads.py

@@ -12,7 +12,7 @@ from threading import Lock
 
 from azure.core.tracing.common import with_current_context
 
-from . import encode_base64, url_quote
+from .import encode_base64, url_quote
 from .request_handlers import get_length
 from .response_handlers import return_response_headers
 

azure/storage/blob/_shared/uploads_async.py

@@ -13,7 +13,7 @@ from itertools import islice
 from math import ceil
 from typing import AsyncGenerator, Union
 
-from . import encode_base64, url_quote
+from .import encode_base64, url_quote
 from .request_handlers import get_length
 from .response_handlers import return_response_headers
 from .uploads import SubStream, IterStreamer  # pylint: disable=unused-import

azure/storage/blob/_shared_access_signature.py

@@ -5,25 +5,17 @@
 # --------------------------------------------------------------------------
 # pylint: disable=docstring-keyword-should-match-keyword-only
 
-from typing import (  # pylint: disable=unused-import
-    Union, Optional, Any, TYPE_CHECKING
-)
+from typing import Union, Optional, Any, 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 +30,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 +48,24 @@ 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,
+        **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 +75,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
@@ -148,11 +157,21 @@ class BlobSharedAccessSignature(SharedAccessSignature):
 
         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,
+        **kwargs: Any
+    ) -> str:
         '''
         Generates a shared access signature for the container.
         Use the returned signature with the sas_token parameter of any BlobService.
@@ -298,7 +317,7 @@ class _BlobSharedAccessHelper(_SharedAccessHelper):
                         sign_string(account_key if user_delegation_key is None else user_delegation_key.value,
                                     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]
@@ -378,22 +397,21 @@ def generate_account_sas(
         start=start,
         ip=ip,
         **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,
+    **kwargs: Any
+) -> str:
     """Generates a shared access signature for a container.
 
     Use the returned signature with the credential parameter of any BlobServiceClient,
@@ -502,20 +520,19 @@ def generate_container_sas(
 
 
 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,
+    **kwargs: Any
+) -> str:
     """Generates a shared access signature for a blob.
 
     Use the returned signature with the credential parameter of any BlobServiceClient,