azure-storage-blob 12.25.0b1__py3-none-any.whl → 12.26.0__py3-none-any.whl

azure/storage/blob/_shared/shared_access_signature.py

@@ -11,42 +11,45 @@ from .parser import _to_utc_datetime
 from .constants import X_MS_VERSION
 from . import sign_string, url_quote
 
+
 # cspell:ignoreRegExp rsc.
 # cspell:ignoreRegExp s..?id
 class QueryStringConstants(object):
-    SIGNED_SIGNATURE = 'sig'
-    SIGNED_PERMISSION = 'sp'
-    SIGNED_START = 'st'
-    SIGNED_EXPIRY = 'se'
-    SIGNED_RESOURCE = 'sr'
-    SIGNED_IDENTIFIER = 'si'
-    SIGNED_IP = 'sip'
-    SIGNED_PROTOCOL = 'spr'
-    SIGNED_VERSION = 'sv'
-    SIGNED_CACHE_CONTROL = 'rscc'
-    SIGNED_CONTENT_DISPOSITION = 'rscd'
-    SIGNED_CONTENT_ENCODING = 'rsce'
-    SIGNED_CONTENT_LANGUAGE = 'rscl'
-    SIGNED_CONTENT_TYPE = 'rsct'
-    START_PK = 'spk'
-    START_RK = 'srk'
-    END_PK = 'epk'
-    END_RK = 'erk'
-    SIGNED_RESOURCE_TYPES = 'srt'
-    SIGNED_SERVICES = 'ss'
-    SIGNED_OID = 'skoid'
-    SIGNED_TID = 'sktid'
-    SIGNED_KEY_START = 'skt'
-    SIGNED_KEY_EXPIRY = 'ske'
-    SIGNED_KEY_SERVICE = 'sks'
-    SIGNED_KEY_VERSION = 'skv'
-    SIGNED_ENCRYPTION_SCOPE = 'ses'
+    SIGNED_SIGNATURE = "sig"
+    SIGNED_PERMISSION = "sp"
+    SIGNED_START = "st"
+    SIGNED_EXPIRY = "se"
+    SIGNED_RESOURCE = "sr"
+    SIGNED_IDENTIFIER = "si"
+    SIGNED_IP = "sip"
+    SIGNED_PROTOCOL = "spr"
+    SIGNED_VERSION = "sv"
+    SIGNED_CACHE_CONTROL = "rscc"
+    SIGNED_CONTENT_DISPOSITION = "rscd"
+    SIGNED_CONTENT_ENCODING = "rsce"
+    SIGNED_CONTENT_LANGUAGE = "rscl"
+    SIGNED_CONTENT_TYPE = "rsct"
+    START_PK = "spk"
+    START_RK = "srk"
+    END_PK = "epk"
+    END_RK = "erk"
+    SIGNED_RESOURCE_TYPES = "srt"
+    SIGNED_SERVICES = "ss"
+    SIGNED_OID = "skoid"
+    SIGNED_TID = "sktid"
+    SIGNED_KEY_START = "skt"
+    SIGNED_KEY_EXPIRY = "ske"
+    SIGNED_KEY_SERVICE = "sks"
+    SIGNED_KEY_VERSION = "skv"
+    SIGNED_ENCRYPTION_SCOPE = "ses"
+    SIGNED_KEY_DELEGATED_USER_TID = "skdutid"
+    SIGNED_DELEGATED_USER_OID = "sduoid"
 
     # for ADLS
-    SIGNED_AUTHORIZED_OID = 'saoid'
-    SIGNED_UNAUTHORIZED_OID = 'suoid'
-    SIGNED_CORRELATION_ID = 'scid'
-    SIGNED_DIRECTORY_DEPTH = 'sdd'
+    SIGNED_AUTHORIZED_OID = "saoid"
+    SIGNED_UNAUTHORIZED_OID = "suoid"
+    SIGNED_CORRELATION_ID = "scid"
+    SIGNED_DIRECTORY_DEPTH = "sdd"
 
     @staticmethod
     def to_list():
@@ -78,6 +81,8 @@ class QueryStringConstants(object):
             QueryStringConstants.SIGNED_KEY_SERVICE,
             QueryStringConstants.SIGNED_KEY_VERSION,
             QueryStringConstants.SIGNED_ENCRYPTION_SCOPE,
+            QueryStringConstants.SIGNED_KEY_DELEGATED_USER_TID,
+            QueryStringConstants.SIGNED_DELEGATED_USER_OID,
             # for ADLS
             QueryStringConstants.SIGNED_AUTHORIZED_OID,
             QueryStringConstants.SIGNED_UNAUTHORIZED_OID,
@@ -87,38 +92,30 @@ class QueryStringConstants(object):
 
 
 class SharedAccessSignature(object):
-    '''
+    """
     Provides a factory for creating account access
     signature tokens with an account name and account key. Users can either
     use the factory or can construct the appropriate service and use the
     generate_*_shared_access_signature method directly.
-    '''
+    """
 
     def __init__(self, account_name, account_key, x_ms_version=X_MS_VERSION):
-        '''
+        """
         :param str account_name:
             The storage account name used to generate the shared access signatures.
         :param str account_key:
             The access key to generate the shares access signatures.
         :param str x_ms_version:
             The service version used to generate the shared access signatures.
-        '''
+        """
         self.account_name = account_name
         self.account_key = account_key
         self.x_ms_version = x_ms_version
 
     def generate_account(
-        self, services,
-        resource_types,
-        permission,
-        expiry,
-        start=None,
-        ip=None,
-        protocol=None,
-        sts_hook=None,
-        **kwargs
+        self, services, resource_types, permission, expiry, start=None, ip=None, protocol=None, sts_hook=None, **kwargs
     ) -> str:
-        '''
+        """
         Generates a shared access signature for the account.
         Use the returned signature with the sas_token parameter of the service
         or to create a new account object.
@@ -165,9 +162,9 @@ class SharedAccessSignature(object):
             For debugging purposes only. If provided, the hook is called with the string to sign
             that was used to generate the SAS.
         :type sts_hook: Optional[Callable[[str], None]]
-        :returns: The generated SAS token for the account.
+        :return: The generated SAS token for the account.
         :rtype: str
-        '''
+        """
         sas = _SharedAccessHelper()
         sas.add_base(permission, expiry, start, ip, protocol, self.x_ms_version)
         sas.add_account(services, resource_types)
@@ -190,7 +187,7 @@ class _SharedAccessHelper(object):
             self.query_dict[name] = str(val) if val is not None else None
 
     def add_encryption_scope(self, **kwargs):
-        self._add_query(QueryStringConstants.SIGNED_ENCRYPTION_SCOPE, kwargs.pop('encryption_scope', None))
+        self._add_query(QueryStringConstants.SIGNED_ENCRYPTION_SCOPE, kwargs.pop("encryption_scope", None))
 
     def add_base(self, permission, expiry, start, ip, protocol, x_ms_version):
         if isinstance(start, date):
@@ -216,11 +213,9 @@ class _SharedAccessHelper(object):
         self._add_query(QueryStringConstants.SIGNED_SERVICES, services)
         self._add_query(QueryStringConstants.SIGNED_RESOURCE_TYPES, resource_types)
 
-    def add_override_response_headers(self, cache_control,
-                                      content_disposition,
-                                      content_encoding,
-                                      content_language,
-                                      content_type):
+    def add_override_response_headers(
+        self, cache_control, content_disposition, content_encoding, content_language, content_type
+    ):
         self._add_query(QueryStringConstants.SIGNED_CACHE_CONTROL, cache_control)
         self._add_query(QueryStringConstants.SIGNED_CONTENT_DISPOSITION, content_disposition)
         self._add_query(QueryStringConstants.SIGNED_CONTENT_ENCODING, content_encoding)
@@ -229,24 +224,25 @@ class _SharedAccessHelper(object):
 
     def add_account_signature(self, account_name, account_key):
         def get_value_to_append(query):
-            return_value = self.query_dict.get(query) or ''
-            return return_value + '\n'
-
-        string_to_sign = \
-            (account_name + '\n' +
-             get_value_to_append(QueryStringConstants.SIGNED_PERMISSION) +
-             get_value_to_append(QueryStringConstants.SIGNED_SERVICES) +
-             get_value_to_append(QueryStringConstants.SIGNED_RESOURCE_TYPES) +
-             get_value_to_append(QueryStringConstants.SIGNED_START) +
-             get_value_to_append(QueryStringConstants.SIGNED_EXPIRY) +
-             get_value_to_append(QueryStringConstants.SIGNED_IP) +
-             get_value_to_append(QueryStringConstants.SIGNED_PROTOCOL) +
-             get_value_to_append(QueryStringConstants.SIGNED_VERSION) +
-             get_value_to_append(QueryStringConstants.SIGNED_ENCRYPTION_SCOPE))
-
-        self._add_query(QueryStringConstants.SIGNED_SIGNATURE,
-                        sign_string(account_key, string_to_sign))
+            return_value = self.query_dict.get(query) or ""
+            return return_value + "\n"
+
+        string_to_sign = (
+            account_name
+            + "\n"
+            + get_value_to_append(QueryStringConstants.SIGNED_PERMISSION)
+            + get_value_to_append(QueryStringConstants.SIGNED_SERVICES)
+            + get_value_to_append(QueryStringConstants.SIGNED_RESOURCE_TYPES)
+            + get_value_to_append(QueryStringConstants.SIGNED_START)
+            + get_value_to_append(QueryStringConstants.SIGNED_EXPIRY)
+            + get_value_to_append(QueryStringConstants.SIGNED_IP)
+            + get_value_to_append(QueryStringConstants.SIGNED_PROTOCOL)
+            + get_value_to_append(QueryStringConstants.SIGNED_VERSION)
+            + get_value_to_append(QueryStringConstants.SIGNED_ENCRYPTION_SCOPE)
+        )
+
+        self._add_query(QueryStringConstants.SIGNED_SIGNATURE, sign_string(account_key, string_to_sign))
         self.string_to_sign = string_to_sign
 
     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])
+        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
 
@@ -41,20 +41,21 @@ def _parallel_uploads(executor, uploader, pending, running):
 
 
 def upload_data_chunks(
-        service=None,
-        uploader_class=None,
-        total_size=None,
-        chunk_size=None,
-        max_concurrency=None,
-        stream=None,
-        validate_content=None,
-        progress_hook=None,
-        **kwargs):
+    service=None,
+    uploader_class=None,
+    total_size=None,
+    chunk_size=None,
+    max_concurrency=None,
+    stream=None,
+    validate_content=None,
+    progress_hook=None,
+    **kwargs,
+):
 
     parallel = max_concurrency > 1
-    if parallel and 'modified_access_conditions' in kwargs:
+    if parallel and "modified_access_conditions" in kwargs:
         # Access conditions do not work with parallelism
-        kwargs['modified_access_conditions'] = None
+        kwargs["modified_access_conditions"] = None
 
     uploader = uploader_class(
         service=service,
@@ -64,7 +65,8 @@ def upload_data_chunks(
         parallel=parallel,
         validate_content=validate_content,
         progress_hook=progress_hook,
-        **kwargs)
+        **kwargs,
+    )
     if parallel:
         with futures.ThreadPoolExecutor(max_concurrency) as executor:
             upload_tasks = uploader.get_chunk_streams()
@@ -81,18 +83,19 @@ def upload_data_chunks(
 
 
 def upload_substream_blocks(
-        service=None,
-        uploader_class=None,
-        total_size=None,
-        chunk_size=None,
-        max_concurrency=None,
-        stream=None,
-        progress_hook=None,
-        **kwargs):
+    service=None,
+    uploader_class=None,
+    total_size=None,
+    chunk_size=None,
+    max_concurrency=None,
+    stream=None,
+    progress_hook=None,
+    **kwargs,
+):
     parallel = max_concurrency > 1
-    if parallel and 'modified_access_conditions' in kwargs:
+    if parallel and "modified_access_conditions" in kwargs:
         # Access conditions do not work with parallelism
-        kwargs['modified_access_conditions'] = None
+        kwargs["modified_access_conditions"] = None
     uploader = uploader_class(
         service=service,
         total_size=total_size,
@@ -100,7 +103,8 @@ def upload_substream_blocks(
         stream=stream,
         parallel=parallel,
         progress_hook=progress_hook,
-        **kwargs)
+        **kwargs,
+    )
 
     if parallel:
         with futures.ThreadPoolExecutor(max_concurrency) as executor:
@@ -120,15 +124,17 @@ def upload_substream_blocks(
 class _ChunkUploader(object):  # pylint: disable=too-many-instance-attributes
 
     def __init__(
-            self, service,
-            total_size,
-            chunk_size,
-            stream,
-            parallel,
-            encryptor=None,
-            padder=None,
-            progress_hook=None,
-            **kwargs):
+        self,
+        service,
+        total_size,
+        chunk_size,
+        stream,
+        parallel,
+        encryptor=None,
+        padder=None,
+        progress_hook=None,
+        **kwargs,
+    ):
         self.service = service
         self.total_size = total_size
         self.chunk_size = chunk_size
@@ -253,7 +259,7 @@ class BlockBlobChunkUploader(_ChunkUploader):
 
     def _upload_chunk(self, chunk_offset, chunk_data):
         # TODO: This is incorrect, but works with recording.
-        index = f'{chunk_offset:032d}'
+        index = f"{chunk_offset:032d}"
         block_id = encode_base64(url_quote(encode_base64(index)))
         self.service.stage_block(
             block_id,
@@ -261,20 +267,20 @@ class BlockBlobChunkUploader(_ChunkUploader):
             chunk_data,
             data_stream_total=self.total_size,
             upload_stream_current=self.progress_total,
-            **self.request_options
+            **self.request_options,
         )
         return index, block_id
 
     def _upload_substream_block(self, index, block_stream):
         try:
-            block_id = f'BlockId{(index//self.chunk_size):05}'
+            block_id = f"BlockId{(index//self.chunk_size):05}"
             self.service.stage_block(
                 block_id,
                 len(block_stream),
                 block_stream,
                 data_stream_total=self.total_size,
                 upload_stream_current=self.progress_total,
-                **self.request_options
+                **self.request_options,
             )
         finally:
             block_stream.close()
@@ -302,11 +308,11 @@ class PageBlobChunkUploader(_ChunkUploader):
                 cls=return_response_headers,
                 data_stream_total=self.total_size,
                 upload_stream_current=self.progress_total,
-                **self.request_options
+                **self.request_options,
             )
 
-            if not self.parallel and self.request_options.get('modified_access_conditions'):
-                self.request_options['modified_access_conditions'].if_match = self.response_headers['etag']
+            if not self.parallel and self.request_options.get("modified_access_conditions"):
+                self.request_options["modified_access_conditions"].if_match = self.response_headers["etag"]
 
     def _upload_substream_block(self, index, block_stream):
         pass
@@ -326,19 +332,20 @@ class AppendBlobChunkUploader(_ChunkUploader):
                 cls=return_response_headers,
                 data_stream_total=self.total_size,
                 upload_stream_current=self.progress_total,
-                **self.request_options
+                **self.request_options,
             )
             self.current_length = int(self.response_headers["blob_append_offset"])
         else:
-            self.request_options['append_position_access_conditions'].append_position = \
+            self.request_options["append_position_access_conditions"].append_position = (
                 self.current_length + chunk_offset
+            )
             self.response_headers = self.service.append_block(
                 body=chunk_data,
                 content_length=len(chunk_data),
                 cls=return_response_headers,
                 data_stream_total=self.total_size,
                 upload_stream_current=self.progress_total,
-                **self.request_options
+                **self.request_options,
             )
 
     def _upload_substream_block(self, index, block_stream):
@@ -356,11 +363,11 @@ class DataLakeFileChunkUploader(_ChunkUploader):
             cls=return_response_headers,
             data_stream_total=self.total_size,
             upload_stream_current=self.progress_total,
-            **self.request_options
+            **self.request_options,
         )
 
-        if not self.parallel and self.request_options.get('modified_access_conditions'):
-            self.request_options['modified_access_conditions'].if_match = self.response_headers['etag']
+        if not self.parallel and self.request_options.get("modified_access_conditions"):
+            self.request_options["modified_access_conditions"].if_match = self.response_headers["etag"]
 
     def _upload_substream_block(self, index, block_stream):
         try:
@@ -371,7 +378,7 @@ class DataLakeFileChunkUploader(_ChunkUploader):
                 cls=return_response_headers,
                 data_stream_total=self.total_size,
                 upload_stream_current=self.progress_total,
-                **self.request_options
+                **self.request_options,
             )
         finally:
             block_stream.close()
@@ -388,9 +395,9 @@ class FileChunkUploader(_ChunkUploader):
             length,
             data_stream_total=self.total_size,
             upload_stream_current=self.progress_total,
-            **self.request_options
+            **self.request_options,
         )
-        return f'bytes={chunk_offset}-{chunk_end}', response
+        return f"bytes={chunk_offset}-{chunk_end}", response
 
     # TODO: Implement this method.
     def _upload_substream_block(self, index, block_stream):