azure-storage-blob 12.19.1__py3-none-any.whl → 12.20.0__py3-none-any.whl

azure/storage/blob/_shared/models.py

@@ -5,8 +5,11 @@
 # --------------------------------------------------------------------------
 # pylint: disable=too-many-instance-attributes
 from enum import Enum
+from typing import Optional
 
 from azure.core import CaseInsensitiveEnumMeta
+from azure.core.configuration import Configuration
+from azure.core.pipeline.policies import UserAgentPolicy
 
 
 def get_enum_value(value):
@@ -269,7 +272,17 @@ class ResourceTypes(object):
         files(e.g. Put Blob, Query Entity, Get Messages, Create File, etc.)
     """
 
-    def __init__(self, service=False, container=False, object=False):  # pylint: disable=redefined-builtin
+    service: bool = False
+    container: bool = False
+    object: bool = False
+    _str: str
+
+    def __init__(
+        self,
+        service: bool = False,
+        container: bool = False,
+        object: bool = False  # pylint: disable=redefined-builtin
+    ) -> None:
         self.service = service
         self.container = container
         self.object = object
@@ -344,9 +357,34 @@ class AccountSasPermissions(object):
         To enable permanent delete on the blob is permitted.
         Valid for Object resource type of Blob only.
     """
-    def __init__(self, read=False, write=False, delete=False,
-                 list=False,  # pylint: disable=redefined-builtin
-                 add=False, create=False, update=False, process=False, delete_previous_version=False, **kwargs):
+
+    read: bool = False
+    write: bool = False
+    delete: bool = False
+    delete_previous_version: bool = False
+    list: bool = False
+    add: bool = False
+    create: bool = False
+    update: bool = False
+    process: bool = False
+    tag: bool = False
+    filter_by_tags: bool = False
+    set_immutability_policy: bool = False
+    permanent_delete: bool = False
+
+    def __init__(
+        self,
+        read: bool = False,
+        write: bool = False,
+        delete: bool = False,
+        list: bool = False,  # pylint: disable=redefined-builtin
+        add: bool = False,
+        create: bool = False,
+        update: bool = False,
+        process: bool = False,
+        delete_previous_version: bool = False,
+        **kwargs
+    ) -> None:
         self.read = read
         self.write = write
         self.delete = delete
@@ -415,15 +453,20 @@ class AccountSasPermissions(object):
 class Services(object):
     """Specifies the services accessible with the account SAS.
 
-    :param bool blob:
-        Access for the `~azure.storage.blob.BlobServiceClient`
-    :param bool queue:
-        Access for the `~azure.storage.queue.QueueServiceClient`
-    :param bool fileshare:
-        Access for the `~azure.storage.fileshare.ShareServiceClient`
+    :keyword bool blob:
+        Access for the `~azure.storage.blob.BlobServiceClient`. Default is False.
+    :keyword bool queue:
+        Access for the `~azure.storage.queue.QueueServiceClient`. Default is False.
+    :keyword bool fileshare:
+        Access for the `~azure.storage.fileshare.ShareServiceClient`. Default is False.
     """
 
-    def __init__(self, blob=False, queue=False, fileshare=False):
+    def __init__(
+        self, *,
+        blob: bool = False,
+        queue: bool = False,
+        fileshare: bool = False
+    ) -> None:
         self.blob = blob
         self.queue = queue
         self.fileshare = fileshare
@@ -451,7 +494,7 @@ class Services(object):
         res_queue = 'q' in string
         res_file = 'f' in string
 
-        parsed = cls(res_blob, res_queue, res_file)
+        parsed = cls(blob=res_blob, queue=res_queue, fileshare=res_file)
         parsed._str = string  # pylint: disable = protected-access
         return parsed
 
@@ -463,22 +506,23 @@ class UserDelegationKey(object):
 
     The fields are saved as simple strings since the user does not have to interact with this object;
     to generate an identify SAS, the user can simply pass it to the right API.
-
-    :ivar str signed_oid:
-        Object ID of this token.
-    :ivar str signed_tid:
-        Tenant ID of the tenant that issued this token.
-    :ivar str signed_start:
-        The datetime this token becomes valid.
-    :ivar str signed_expiry:
-        The datetime this token expires.
-    :ivar str signed_service:
-        What service this key is valid for.
-    :ivar str signed_version:
-        The version identifier of the REST service that created this token.
-    :ivar str value:
-        The user delegation key.
     """
+
+    signed_oid: Optional[str] = None
+    """Object ID of this token."""
+    signed_tid: Optional[str] = None
+    """Tenant ID of the tenant that issued this token."""
+    signed_start: Optional[str] = None
+    """The datetime this token becomes valid."""
+    signed_expiry: Optional[str] = None
+    """The datetime this token expires."""
+    signed_service: Optional[str] = None
+    """What service this key is valid for."""
+    signed_version: Optional[str] = None
+    """The version identifier of the REST service that created this token."""
+    value: Optional[str] = None
+    """The user delegation key."""
+
     def __init__(self):
         self.signed_oid = None
         self.signed_tid = None
@@ -487,3 +531,52 @@ class UserDelegationKey(object):
         self.signed_service = None
         self.signed_version = None
         self.value = None
+
+
+class StorageConfiguration(Configuration):
+    """
+    Specifies the configurable values used in Azure Storage.
+
+    :param int max_single_put_size: If the blob size is less than or equal max_single_put_size, then the blob will be
+        uploaded with only one http PUT request. If the blob size is larger than max_single_put_size,
+        the blob will be uploaded in chunks. Defaults to 64*1024*1024, or 64MB.
+    :param int copy_polling_interval: The interval in seconds for polling copy operations.
+    :param int max_block_size: The maximum chunk size for uploading a block blob in chunks.
+        Defaults to 4*1024*1024, or 4MB.
+    :param int min_large_block_upload_threshold: The minimum chunk size required to use the memory efficient
+        algorithm when uploading a block blob.
+    :param bool use_byte_buffer: Use a byte buffer for block blob uploads. Defaults to False.
+    :param int max_page_size: The maximum chunk size for uploading a page blob. Defaults to 4*1024*1024, or 4MB.
+    :param int min_large_chunk_upload_threshold: The max size for a single put operation.
+    :param int max_single_get_size: The maximum size for a blob to be downloaded in a single call,
+        the exceeded part will be downloaded in chunks (could be parallel). Defaults to 32*1024*1024, or 32MB.
+    :param int max_chunk_get_size: The maximum chunk size used for downloading a blob. Defaults to 4*1024*1024,
+        or 4MB.
+    :param int max_range_size: The max range size for file upload.
+
+    """
+
+    max_single_put_size: int
+    copy_polling_interval: int
+    max_block_size: int
+    min_large_block_upload_threshold: int
+    use_byte_buffer: bool
+    max_page_size: int
+    min_large_chunk_upload_threshold: int
+    max_single_get_size: int
+    max_chunk_get_size: int
+    max_range_size: int
+    user_agent_policy: UserAgentPolicy
+
+    def __init__(self, **kwargs):
+        super(StorageConfiguration, self).__init__(**kwargs)
+        self.max_single_put_size = kwargs.pop('max_single_put_size', 64 * 1024 * 1024)
+        self.copy_polling_interval = 15
+        self.max_block_size = kwargs.pop('max_block_size', 4 * 1024 * 1024)
+        self.min_large_block_upload_threshold = kwargs.get('min_large_block_upload_threshold', 4 * 1024 * 1024 + 1)
+        self.use_byte_buffer = kwargs.pop('use_byte_buffer', False)
+        self.max_page_size = kwargs.pop('max_page_size', 4 * 1024 * 1024)
+        self.min_large_chunk_upload_threshold = kwargs.pop('min_large_chunk_upload_threshold', 100 * 1024 * 1024 + 1)
+        self.max_single_get_size = kwargs.pop('max_single_get_size', 32 * 1024 * 1024)
+        self.max_chunk_get_size = kwargs.pop('max_chunk_get_size', 4 * 1024 * 1024)
+        self.max_range_size = kwargs.pop('max_range_size', 4 * 1024 * 1024)

azure/storage/blob/_shared/parser.py

@@ -6,6 +6,7 @@
 
 import sys
 from datetime import datetime, timezone
+from typing import Optional
 
 EPOCH_AS_FILETIME = 116444736000000000  # January 1, 1970 as MS filetime
 HUNDREDS_OF_NANOSECONDS = 10000000
@@ -20,10 +21,10 @@ else:
     _str = str
 
 
-def _to_utc_datetime(value):
+def _to_utc_datetime(value: datetime) -> str:
     return value.strftime('%Y-%m-%dT%H:%M:%SZ')
 
-def _rfc_1123_to_datetime(rfc_1123: str) -> datetime:
+def _rfc_1123_to_datetime(rfc_1123: str) -> Optional[datetime]:
     """Converts an RFC 1123 date string to a UTC datetime.
 
     :param str rfc_1123: The time and date in RFC 1123 format.
@@ -35,7 +36,7 @@ def _rfc_1123_to_datetime(rfc_1123: str) -> datetime:
 
     return datetime.strptime(rfc_1123, "%a, %d %b %Y %H:%M:%S %Z")
 
-def _filetime_to_datetime(filetime: str) -> datetime:
+def _filetime_to_datetime(filetime: str) -> Optional[datetime]:
     """Converts an MS filetime string to a UTC datetime. "0" indicates None.
     If parsing MS Filetime fails, tries RFC 1123 as backup.
 
@@ -48,11 +49,11 @@ def _filetime_to_datetime(filetime: str) -> datetime:
 
     # Try to convert to MS Filetime
     try:
-        filetime = int(filetime)
-        if filetime == 0:
+        temp_filetime = int(filetime)
+        if temp_filetime == 0:
             return None
 
-        return datetime.fromtimestamp((filetime - EPOCH_AS_FILETIME) / HUNDREDS_OF_NANOSECONDS, tz=timezone.utc)
+        return datetime.fromtimestamp((temp_filetime - EPOCH_AS_FILETIME) / HUNDREDS_OF_NANOSECONDS, tz=timezone.utc)
     except ValueError:
         pass
 

azure/storage/blob/_shared/policies.py

@@ -6,29 +6,22 @@
 
 import base64
 import hashlib
-import re
-import random
-from time import time
-from io import SEEK_SET, UnsupportedOperation
 import logging
+import random
+import re
 import uuid
-from typing import Any, TYPE_CHECKING
-from wsgiref.handlers import format_date_time
-try:
-    from urllib.parse import (
-        urlparse,
+from io import SEEK_SET, UnsupportedOperation
+from time import time
+from typing import Any, Dict, Optional, TYPE_CHECKING
+from urllib.parse import (
         parse_qsl,
-        urlunparse,
         urlencode,
-    )
-except ImportError:
-    from urllib import urlencode # type: ignore
-    from urlparse import ( # type: ignore
         urlparse,
-        parse_qsl,
         urlunparse,
-    )
+)
+from wsgiref.handlers import format_date_time
 
+from azure.core.exceptions import AzureError, ServiceRequestError, ServiceResponseError
 from azure.core.pipeline.policies import (
     BearerTokenCredentialPolicy,
     HeadersPolicy,
@@ -37,7 +30,6 @@ from azure.core.pipeline.policies import (
     RequestHistory,
     SansIOHTTPPolicy,
 )
-from azure.core.exceptions import AzureError, ServiceRequestError, ServiceResponseError
 
 from .authentication import StorageHttpChallenge
 from .constants import DEFAULT_OAUTH_SCOPE
@@ -50,7 +42,10 @@ except NameError:
 
 if TYPE_CHECKING:
     from azure.core.credentials import TokenCredential
-    from azure.core.pipeline import PipelineRequest, PipelineResponse
+    from azure.core.pipeline.transport import (  # pylint: disable=non-abstract-transport-import
+        PipelineRequest,
+        PipelineResponse
+    )
 
 
 _LOGGER = logging.getLogger(__name__)
@@ -128,8 +123,7 @@ class QueueMessagePolicy(SansIOHTTPPolicy):
 class StorageHeadersPolicy(HeadersPolicy):
     request_id_header_name = 'x-ms-client-request-id'
 
-    def on_request(self, request):
-        # type: (PipelineRequest, Any) -> None
+    def on_request(self, request: "PipelineRequest") -> None:
         super(StorageHeadersPolicy, self).on_request(request)
         current_time = format_date_time(time())
         request.http_request.headers['x-ms-date'] = current_time
@@ -159,8 +153,7 @@ class StorageHosts(SansIOHTTPPolicy):
         self.hosts = hosts
         super(StorageHosts, self).__init__()
 
-    def on_request(self, request):
-        # type: (PipelineRequest, Any) -> None
+    def on_request(self, request: "PipelineRequest") -> None:
         request.context.options['hosts'] = self.hosts
         parsed_url = urlparse(request.http_request.url)
 
@@ -191,12 +184,12 @@ class StorageLoggingPolicy(NetworkTraceLoggingPolicy):
 
     This accepts both global configuration, and per-request level with "enable_http_logger"
     """
-    def __init__(self, logging_enable=False, **kwargs):
+
+    def __init__(self, logging_enable: bool = False, **kwargs) -> None:
         self.logging_body = kwargs.pop("logging_body", False)
         super(StorageLoggingPolicy, self).__init__(logging_enable=logging_enable, **kwargs)
 
-    def on_request(self, request):
-        # type: (PipelineRequest, Any) -> None
+    def on_request(self, request: "PipelineRequest") -> None:
         http_request = request.http_request
         options = request.context.options
         self.logging_body = self.logging_body or options.pop("logging_body", False)
@@ -236,8 +229,7 @@ class StorageLoggingPolicy(NetworkTraceLoggingPolicy):
             except Exception as err:  # pylint: disable=broad-except
                 _LOGGER.debug("Failed to log request: %r", err)
 
-    def on_response(self, request, response):
-        # type: (PipelineRequest, PipelineResponse, Any) -> None
+    def on_response(self, request: "PipelineRequest", response: "PipelineResponse") -> None:
         if response.context.pop("logging_enable", self.enable_http_logger):
             if not _LOGGER.isEnabledFor(logging.DEBUG):
                 return
@@ -280,8 +272,7 @@ class StorageRequestHook(SansIOHTTPPolicy):
         self._request_callback = kwargs.get('raw_request_hook')
         super(StorageRequestHook, self).__init__()
 
-    def on_request(self, request):
-        # type: (PipelineRequest, **Any) -> PipelineResponse
+    def on_request(self, request: "PipelineRequest") -> None:
         request_callback = request.context.options.pop('raw_request_hook', self._request_callback)
         if request_callback:
             request_callback(request)
@@ -293,8 +284,7 @@ class StorageResponseHook(HTTPPolicy):
         self._response_callback = kwargs.get('raw_response_hook')
         super(StorageResponseHook, self).__init__()
 
-    def send(self, request):
-        # type: (PipelineRequest) -> PipelineResponse
+    def send(self, request: "PipelineRequest") -> "PipelineResponse":
         # Values could be 0
         data_stream_total = request.context.get('data_stream_total')
         if data_stream_total is None:
@@ -327,9 +317,10 @@ class StorageResponseHook(HTTPPolicy):
         elif should_update_counts and upload_stream_current is not None:
             upload_stream_current += int(response.http_request.headers.get('Content-Length', 0))
         for pipeline_obj in [request, response]:
-            pipeline_obj.context['data_stream_total'] = data_stream_total
-            pipeline_obj.context['download_stream_current'] = download_stream_current
-            pipeline_obj.context['upload_stream_current'] = upload_stream_current
+            if hasattr(pipeline_obj, 'context'):
+                pipeline_obj.context['data_stream_total'] = data_stream_total
+                pipeline_obj.context['download_stream_current'] = download_stream_current
+                pipeline_obj.context['upload_stream_current'] = upload_stream_current
         if response_callback:
             response_callback(response)
             request.context['response_callback'] = response_callback
@@ -344,7 +335,7 @@ class StorageContentValidation(SansIOHTTPPolicy):
     """
     header_name = 'Content-MD5'
 
-    def __init__(self, **kwargs):  # pylint: disable=unused-argument
+    def __init__(self, **kwargs: Any) -> None:  # pylint: disable=unused-argument
         super(StorageContentValidation, self).__init__()
 
     @staticmethod
@@ -372,8 +363,7 @@ class StorageContentValidation(SansIOHTTPPolicy):
 
         return md5.digest()
 
-    def on_request(self, request):
-        # type: (PipelineRequest, Any) -> None
+    def on_request(self, request: "PipelineRequest") -> None:
         validate_content = request.context.options.pop('validate_content', False)
         if validate_content and request.http_request.method != 'GET':
             computed_md5 = encode_base64(StorageContentValidation.get_content_md5(request.http_request.data))
@@ -381,7 +371,7 @@ class StorageContentValidation(SansIOHTTPPolicy):
             request.context['validate_content_md5'] = computed_md5
         request.context['validate_content'] = validate_content
 
-    def on_response(self, request, response):
+    def on_response(self, request: "PipelineRequest", response: "PipelineResponse") -> None:
         if response.context.get('validate_content', False) and response.http_response.headers.get('content-md5'):
             computed_md5 = request.context.get('validate_content_md5') or \
                 encode_base64(StorageContentValidation.get_content_md5(response.http_response.body()))
@@ -398,7 +388,18 @@ class StorageRetryPolicy(HTTPPolicy):
     The base class for Exponential and Linear retries containing shared code.
     """
 
-    def __init__(self, **kwargs):
+    total_retries: int
+    """The max number of retries."""
+    connect_retries: int
+    """The max number of connect retries."""
+    retry_read: int
+    """The max number of read retries."""
+    retry_status: int
+    """The max number of status retries."""
+    retry_to_secondary: bool
+    """Whether the secondary endpoint should be retried."""
+
+    def __init__(self, **kwargs: Any) -> None:
         self.total_retries = kwargs.pop('retry_total', 10)
         self.connect_retries = kwargs.pop('retry_connect', 3)
         self.read_retries = kwargs.pop('retry_read', 3)
@@ -406,11 +407,11 @@ class StorageRetryPolicy(HTTPPolicy):
         self.retry_to_secondary = kwargs.pop('retry_to_secondary', False)
         super(StorageRetryPolicy, self).__init__()
 
-    def _set_next_host_location(self, settings, request):
+    def _set_next_host_location(self, settings: Dict[str, Any], request: "PipelineRequest") -> None:
         """
         A function which sets the next host location on the request, if applicable.
 
-        :param Optional[Dict[str, Any]] settings: The configurable values pertaining to the next host location.
+        :param Dict[str, Any]] settings: The configurable values pertaining to the next host location.
         :param PipelineRequest request: A pipeline request object.
         """
         if settings['hosts'] and all(settings['hosts'].values()):
@@ -423,7 +424,7 @@ class StorageRetryPolicy(HTTPPolicy):
             updated = url._replace(netloc=settings['hosts'].get(settings['mode']))
             request.url = updated.geturl()
 
-    def configure_retries(self, request):
+    def configure_retries(self, request: "PipelineRequest") -> Dict[str, Any]:
         body_position = None
         if hasattr(request.http_request.body, 'read'):
             try:
@@ -446,11 +447,11 @@ class StorageRetryPolicy(HTTPPolicy):
             'history': []
         }
 
-    def get_backoff_time(self, settings):  # pylint: disable=unused-argument
+    def get_backoff_time(self, settings: Dict[str, Any]) -> float:  # pylint: disable=unused-argument
         """ Formula for computing the current backoff.
         Should be calculated by child class.
 
-        :param Optional[Dict[str, Any]] settings: The configurable values pertaining to the backoff time.
+        :param Dict[str, Any]] settings: The configurable values pertaining to the backoff time.
         :returns: The backoff time.
         :rtype: float
         """
@@ -462,15 +463,20 @@ class StorageRetryPolicy(HTTPPolicy):
             return
         transport.sleep(backoff)
 
-    def increment(self, settings, request, response=None, error=None):
+    def increment(
+        self, settings: Dict[str, Any],
+        request: "PipelineRequest",
+        response: Optional["PipelineResponse"] = None,
+        error: Optional[AzureError] = None
+    ) -> bool:
         """Increment the retry counters.
 
-        :param Optional[Dict[str, Any]] settings: The configurable values pertaining to the increment operation.
-        :param "PipelineRequest" request: A pipeline request object.
-        :param "PipelineResponse": A pipeline response object.
+        :param Dict[str, Any]] settings: The configurable values pertaining to the increment operation.
+        :param PipelineRequest request: A pipeline request object.
+        :param Optional[PipelineResponse] response: A pipeline response object.
         :param error: An error encountered during the request, or
             None if the response was received successfully.
-        :paramtype error: Union[ServiceRequestError, ServiceResponseError]
+        :type error: Optional[AzureError]
         :returns: Whether the retry attempts are exhausted.
         :rtype: bool
         """
@@ -556,9 +562,23 @@ class StorageRetryPolicy(HTTPPolicy):
 class ExponentialRetry(StorageRetryPolicy):
     """Exponential retry."""
 
-    def __init__(self, initial_backoff=15, increment_base=3, retry_total=3,
-                 retry_to_secondary=False, random_jitter_range=3, **kwargs):
-        '''
+    initial_backoff: int
+    """The initial backoff interval, in seconds, for the first retry."""
+    increment_base: int
+    """The base, in seconds, to increment the initial_backoff by after the
+    first retry."""
+    random_jitter_range: int
+    """A number in seconds which indicates a range to jitter/randomize for the back-off interval."""
+
+    def __init__(
+        self, initial_backoff: int = 15,
+        increment_base: int = 3,
+        retry_total: int = 3,
+        retry_to_secondary: bool = False,
+        random_jitter_range: int = 3,
+        **kwargs: Any
+    ) -> None:
+        """
         Constructs an Exponential retry object. The initial_backoff is used for
         the first retry. Subsequent retries are retried after initial_backoff +
         increment_power^retry_count seconds.
@@ -568,7 +588,7 @@ class ExponentialRetry(StorageRetryPolicy):
         :param int increment_base:
             The base, in seconds, to increment the initial_backoff by after the
             first retry.
-        :param int max_attempts:
+        :param int retry_total:
             The maximum number of retry attempts.
         :param bool retry_to_secondary:
             Whether the request should be retried to secondary, if able. This should
@@ -577,22 +597,22 @@ class ExponentialRetry(StorageRetryPolicy):
         :param int random_jitter_range:
             A number in seconds which indicates a range to jitter/randomize for the back-off interval.
             For example, a random_jitter_range of 3 results in the back-off interval x to vary between x+3 and x-3.
-        '''
+        """
         self.initial_backoff = initial_backoff
         self.increment_base = increment_base
         self.random_jitter_range = random_jitter_range
         super(ExponentialRetry, self).__init__(
             retry_total=retry_total, retry_to_secondary=retry_to_secondary, **kwargs)
 
-    def get_backoff_time(self, settings):
+    def get_backoff_time(self, settings: Dict[str, Any]) -> float:
         """
         Calculates how long to sleep before retrying.
 
-        :param Optional[Dict[str, Any]] settings: The configurable values pertaining to get backoff time.
+        :param Dict[str, Any]] settings: The configurable values pertaining to get backoff time.
         :returns:
-            An integer indicating how long to wait before retrying the request,
+            A float indicating how long to wait before retrying the request,
             or None to indicate no retry should be performed.
-        :rtype: int or None
+        :rtype: float
         """
         random_generator = random.Random()
         backoff = self.initial_backoff + (0 if settings['count'] == 0 else pow(self.increment_base, settings['count']))
@@ -604,13 +624,24 @@ class ExponentialRetry(StorageRetryPolicy):
 class LinearRetry(StorageRetryPolicy):
     """Linear retry."""
 
-    def __init__(self, backoff=15, retry_total=3, retry_to_secondary=False, random_jitter_range=3, **kwargs):
+    initial_backoff: int
+    """The backoff interval, in seconds, between retries."""
+    random_jitter_range: int
+    """A number in seconds which indicates a range to jitter/randomize for the back-off interval."""
+
+    def __init__(
+        self, backoff: int = 15,
+        retry_total: int = 3,
+        retry_to_secondary: bool = False,
+        random_jitter_range: int = 3,
+        **kwargs: Any
+    ) -> None:
         """
         Constructs a Linear retry object.
 
         :param int backoff:
             The backoff interval, in seconds, between retries.
-        :param int max_attempts:
+        :param int retry_total:
             The maximum number of retry attempts.
         :param bool retry_to_secondary:
             Whether the request should be retried to secondary, if able. This should
@@ -625,15 +656,15 @@ class LinearRetry(StorageRetryPolicy):
         super(LinearRetry, self).__init__(
             retry_total=retry_total, retry_to_secondary=retry_to_secondary, **kwargs)
 
-    def get_backoff_time(self, settings):
+    def get_backoff_time(self, settings: Dict[str, Any]) -> float:
         """
         Calculates how long to sleep before retrying.
 
-        :param Optional[Dict[str, Any]] settings: The configurable values pertaining to the backoff time.
+        :param Dict[str, Any]] settings: The configurable values pertaining to the backoff time.
         :returns:
-            An integer indicating how long to wait before retrying the request,
+            A float indicating how long to wait before retrying the request,
             or None to indicate no retry should be performed.
-        :rtype: int or None
+        :rtype: float
         """
         random_generator = random.Random()
         # the backoff interval normally does not change, however there is the possibility
@@ -650,8 +681,7 @@ class StorageBearerTokenCredentialPolicy(BearerTokenCredentialPolicy):
     def __init__(self, credential: "TokenCredential", audience: str, **kwargs: Any) -> None:
         super(StorageBearerTokenCredentialPolicy, self).__init__(credential, audience, **kwargs)
 
-    def on_challenge(self, request, response):
-        # type: (PipelineRequest, PipelineResponse) -> bool
+    def on_challenge(self, request: "PipelineRequest", response: "PipelineResponse") -> bool:
         try:
             auth_header = response.http_response.headers.get("WWW-Authenticate")
             challenge = StorageHttpChallenge(auth_header)