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

azure/storage/blob/_quick_query_helper.py

@@ -5,7 +5,10 @@
 # --------------------------------------------------------------------------
 
 from io import BytesIO
-from typing import Any, Dict, Generator, IO, Iterable, Optional, Type, Union, TYPE_CHECKING
+from typing import (
+    Any, Dict, Generator, IO, Iterable, Optional, Type,
+    TYPE_CHECKING
+)
 
 from ._shared.avro.avro_io import DatumReader
 from ._shared.avro.datafile import DataFileReader
@@ -14,11 +17,11 @@ if TYPE_CHECKING:
     from ._models import BlobQueryError
 
 
-class BlobQueryReader(object):  # pylint: disable=too-many-instance-attributes
+class BlobQueryReader:  # pylint: disable=too-many-instance-attributes
     """A streaming object to read query results."""
 
     name: str
-    """The name of the blob being quered."""
+    """The name of the blob being queried."""
     container: str
     """The name of the container where the blob is."""
     response_headers: Dict[str, Any]
@@ -28,8 +31,7 @@ class BlobQueryReader(object):  # pylint: disable=too-many-instance-attributes
     method will return these lines via a generator."""
 
     def __init__(
-        self,
-        name: str = None,  # type: ignore [assignment]
+        self, name: str = None,  # type: ignore [assignment]
         container: str = None,  # type: ignore [assignment]
         errors: Any = None,
         record_delimiter: str = '\n',
@@ -50,7 +52,7 @@ class BlobQueryReader(object):  # pylint: disable=too-many-instance-attributes
         self._first_result = self._process_record(next(self._parsed_results))
         self._error_cls = error_cls
 
-    def __len__(self):
+    def __len__(self) -> int:
         return self._size
 
     def _process_record(self, result: Dict[str, Any]) -> Optional[bytes]:
@@ -77,21 +79,19 @@ class BlobQueryReader(object):  # pylint: disable=too-many-instance-attributes
             if processed_result is not None:
                 yield processed_result
 
-    def readall(self) -> Union[bytes, str]:
+    def readall(self) -> bytes:
         """Return all query results.
 
         This operation is blocking until all data is downloaded.
-        If encoding has been configured - this will be used to decode individual
-        records are they are received.
 
-        :returns: The query results.
-        :rtype: Union[bytes, str]
+        :return: The query results.
+        :rtype: bytes
         """
         stream = BytesIO()
         self.readinto(stream)
         data = stream.getvalue()
         if self._encoding:
-            return data.decode(self._encoding)
+            return data.decode(self._encoding)  # type: ignore [return-value]
         return data
 
     def readinto(self, stream: IO) -> None:
@@ -100,34 +100,30 @@ class BlobQueryReader(object):  # pylint: disable=too-many-instance-attributes
         :param IO stream:
             The stream to download to. This can be an open file-handle,
             or any writable stream.
-        :returns: None
+        :return: None
         """
         for record in self._iter_stream():
             stream.write(record)
 
-    def records(self) -> Iterable[Union[bytes, str]]:
+    def records(self) -> Iterable[bytes]:
         """Returns a record generator for the query result.
 
         Records will be returned line by line.
-        If encoding has been configured - this will be used to decode individual
-        records are they are received.
 
-        :returns: A record generator for the query result.
-        :rtype: Iterable[Union[bytes, str]]
+        :return: A record generator for the query result.
+        :rtype: Iterable[bytes]
         """
         delimiter = self.record_delimiter.encode('utf-8')
         for record_chunk in self._iter_stream():
             for record in record_chunk.split(delimiter):
                 if self._encoding:
-                    yield record.decode(self._encoding)
+                    yield record.decode(self._encoding)  # type: ignore [misc]
                 else:
                     yield record
 
 
-class QuickQueryStreamer(object):
-    """
-    File-like streaming iterator.
-    """
+class QuickQueryStreamer:
+    """File-like streaming iterator."""
 
     def __init__(self, generator):
         self.generator = generator
@@ -183,7 +179,7 @@ class QuickQueryStreamer(object):
         if relative_start < 0:
             raise ValueError("Buffer has dumped too much data")
         relative_end = relative_start + size
-        data = self._buf[relative_start: relative_end]
+        data = self._buf[relative_start:relative_end]
 
         # dump the extra data in buffer
         # buffer start--------------------16bytes----current read position

azure/storage/blob/_serialize.py

@@ -59,6 +59,7 @@ _SUPPORTED_API_VERSIONS = [
     '2024-11-04',
     '2025-01-05',
     '2025-05-05',
+    '2025-07-05',
 ]
 
 

azure/storage/blob/_shared/__init__.py

@@ -11,7 +11,7 @@ import hmac
 try:
     from urllib.parse import quote, unquote
 except ImportError:
-    from urllib2 import quote, unquote # type: ignore
+    from urllib2 import quote, unquote  # type: ignore
 
 
 def url_quote(url):
@@ -24,20 +24,20 @@ def url_unquote(url):
 
 def encode_base64(data):
     if isinstance(data, str):
-        data = data.encode('utf-8')
+        data = data.encode("utf-8")
     encoded = base64.b64encode(data)
-    return encoded.decode('utf-8')
+    return encoded.decode("utf-8")
 
 
 def decode_base64_to_bytes(data):
     if isinstance(data, str):
-        data = data.encode('utf-8')
+        data = data.encode("utf-8")
     return base64.b64decode(data)
 
 
 def decode_base64_to_text(data):
     decoded_bytes = decode_base64_to_bytes(data)
-    return decoded_bytes.decode('utf-8')
+    return decoded_bytes.decode("utf-8")
 
 
 def sign_string(key, string_to_sign, key_is_base64=True):
@@ -45,9 +45,9 @@ def sign_string(key, string_to_sign, key_is_base64=True):
         key = decode_base64_to_bytes(key)
     else:
         if isinstance(key, str):
-            key = key.encode('utf-8')
+            key = key.encode("utf-8")
     if isinstance(string_to_sign, str):
-        string_to_sign = string_to_sign.encode('utf-8')
+        string_to_sign = string_to_sign.encode("utf-8")
     signed_hmac_sha256 = hmac.HMAC(key, string_to_sign, hashlib.sha256)
     digest = signed_hmac_sha256.digest()
     encoded_digest = encode_base64(digest)

azure/storage/blob/_shared/authentication.py

@@ -28,6 +28,7 @@ from . import sign_string
 logger = logging.getLogger(__name__)
 
 
+# fmt: off
 table_lv0 = [
     0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
     0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
@@ -51,6 +52,8 @@ table_lv4 = [
     0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
     0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
 ]
+# fmt: on
+
 
 def compare(lhs: str, rhs: str) -> int:  # pylint:disable=too-many-return-statements
     tables = [table_lv0, table_lv4]
@@ -95,6 +98,7 @@ def _wrap_exception(ex, desired_type):
         msg = ex.args[0]
     return desired_type(msg)
 
+
 # This method attempts to emulate the sorting done by the service
 def _storage_header_sort(input_headers: List[Tuple[str, str]]) -> List[Tuple[str, str]]:
 
@@ -135,38 +139,42 @@ class SharedKeyCredentialPolicy(SansIOHTTPPolicy):
     @staticmethod
     def _get_headers(request, headers_to_sign):
         headers = dict((name.lower(), value) for name, value in request.http_request.headers.items() if value)
-        if 'content-length' in headers and headers['content-length'] == '0':
-            del headers['content-length']
-        return '\n'.join(headers.get(x, '') for x in headers_to_sign) + '\n'
+        if "content-length" in headers and headers["content-length"] == "0":
+            del headers["content-length"]
+        return "\n".join(headers.get(x, "") for x in headers_to_sign) + "\n"
 
     @staticmethod
     def _get_verb(request):
-        return request.http_request.method + '\n'
+        return request.http_request.method + "\n"
 
     def _get_canonicalized_resource(self, request):
         uri_path = urlparse(request.http_request.url).path
         try:
-            if isinstance(request.context.transport, AioHttpTransport) or \
-                    isinstance(getattr(request.context.transport, "_transport", None), AioHttpTransport) or \
-                    isinstance(getattr(getattr(request.context.transport, "_transport", None), "_transport", None),
-                               AioHttpTransport):
+            if (
+                isinstance(request.context.transport, AioHttpTransport)
+                or isinstance(getattr(request.context.transport, "_transport", None), AioHttpTransport)
+                or isinstance(
+                    getattr(getattr(request.context.transport, "_transport", None), "_transport", None),
+                    AioHttpTransport,
+                )
+            ):
                 uri_path = URL(uri_path)
-                return '/' + self.account_name + str(uri_path)
+                return "/" + self.account_name + str(uri_path)
         except TypeError:
             pass
-        return '/' + self.account_name + uri_path
+        return "/" + self.account_name + uri_path
 
     @staticmethod
     def _get_canonicalized_headers(request):
-        string_to_sign = ''
+        string_to_sign = ""
         x_ms_headers = []
         for name, value in request.http_request.headers.items():
-            if name.startswith('x-ms-'):
+            if name.startswith("x-ms-"):
                 x_ms_headers.append((name.lower(), value))
         x_ms_headers = _storage_header_sort(x_ms_headers)
         for name, value in x_ms_headers:
             if value is not None:
-                string_to_sign += ''.join([name, ':', value, '\n'])
+                string_to_sign += "".join([name, ":", value, "\n"])
         return string_to_sign
 
     @staticmethod
@@ -174,37 +182,46 @@ class SharedKeyCredentialPolicy(SansIOHTTPPolicy):
         sorted_queries = list(request.http_request.query.items())
         sorted_queries.sort()
 
-        string_to_sign = ''
+        string_to_sign = ""
         for name, value in sorted_queries:
             if value is not None:
-                string_to_sign += '\n' + name.lower() + ':' + unquote(value)
+                string_to_sign += "\n" + name.lower() + ":" + unquote(value)
 
         return string_to_sign
 
     def _add_authorization_header(self, request, string_to_sign):
         try:
             signature = sign_string(self.account_key, string_to_sign)
-            auth_string = 'SharedKey ' + self.account_name + ':' + signature
-            request.http_request.headers['Authorization'] = auth_string
+            auth_string = "SharedKey " + self.account_name + ":" + signature
+            request.http_request.headers["Authorization"] = auth_string
         except Exception as ex:
             # Wrap any error that occurred as signing error
             # Doing so will clarify/locate the source of problem
             raise _wrap_exception(ex, AzureSigningError) from ex
 
     def on_request(self, request):
-        string_to_sign = \
-            self._get_verb(request) + \
-            self._get_headers(
+        string_to_sign = (
+            self._get_verb(request)
+            + self._get_headers(
                 request,
                 [
-                    'content-encoding', 'content-language', 'content-length',
-                    'content-md5', 'content-type', 'date', 'if-modified-since',
-                    'if-match', 'if-none-match', 'if-unmodified-since', 'byte_range'
-                ]
-            ) + \
-            self._get_canonicalized_headers(request) + \
-            self._get_canonicalized_resource(request) + \
-            self._get_canonicalized_resource_query(request)
+                    "content-encoding",
+                    "content-language",
+                    "content-length",
+                    "content-md5",
+                    "content-type",
+                    "date",
+                    "if-modified-since",
+                    "if-match",
+                    "if-none-match",
+                    "if-unmodified-since",
+                    "byte_range",
+                ],
+            )
+            + self._get_canonicalized_headers(request)
+            + self._get_canonicalized_resource(request)
+            + self._get_canonicalized_resource_query(request)
+        )
 
         self._add_authorization_header(request, string_to_sign)
         # logger.debug("String_to_sign=%s", string_to_sign)
@@ -212,7 +229,7 @@ class SharedKeyCredentialPolicy(SansIOHTTPPolicy):
 
 class StorageHttpChallenge(object):
     def __init__(self, challenge):
-        """ Parses an HTTP WWW-Authentication Bearer challenge from the Storage service. """
+        """Parses an HTTP WWW-Authentication Bearer challenge from the Storage service."""
         if not challenge:
             raise ValueError("Challenge cannot be empty")
 
@@ -221,7 +238,7 @@ class StorageHttpChallenge(object):
 
         # name=value pairs either comma or space separated with values possibly being
         # enclosed in quotes
-        for item in re.split('[, ]', trimmed_challenge):
+        for item in re.split("[, ]", trimmed_challenge):
             comps = item.split("=")
             if len(comps) == 2:
                 key = comps[0].strip(' "')
@@ -230,11 +247,11 @@ class StorageHttpChallenge(object):
                     self._parameters[key] = value
 
         # Extract and verify required parameters
-        self.authorization_uri = self._parameters.get('authorization_uri')
+        self.authorization_uri = self._parameters.get("authorization_uri")
         if not self.authorization_uri:
             raise ValueError("Authorization Uri not found")
 
-        self.resource_id = self._parameters.get('resource_id')
+        self.resource_id = self._parameters.get("resource_id")
         if not self.resource_id:
             raise ValueError("Resource id not found")
 

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

@@ -42,8 +42,8 @@ logger = logging.getLogger(__name__)
 # ------------------------------------------------------------------------------
 # Constants
 
-STRUCT_FLOAT = struct.Struct('<f')  # little-endian float
-STRUCT_DOUBLE = struct.Struct('<d')  # little-endian double
+STRUCT_FLOAT = struct.Struct("<f")  # little-endian float
+STRUCT_DOUBLE = struct.Struct("<d")  # little-endian double
 
 # ------------------------------------------------------------------------------
 # Exceptions
@@ -56,6 +56,7 @@ class SchemaResolutionException(schema.AvroException):
             fail_msg += f"\nWriter's Schema: {pretty_writers}"
         schema.AvroException.__init__(self, fail_msg)
 
+
 # ------------------------------------------------------------------------------
 # Decoder
 
@@ -78,14 +79,14 @@ class BinaryDecoder(object):
         """Read n bytes.
 
         :param int n: Number of bytes to read.
-        :returns: The next n bytes from the input.
+        :return: The next n bytes from the input.
         :rtype: bytes
         """
-        assert (n >= 0), n
+        assert n >= 0, n
         input_bytes = self.reader.read(n)
         if n > 0 and not input_bytes:
             raise StopIteration
-        assert (len(input_bytes) == n), input_bytes
+        assert len(input_bytes) == n, input_bytes
         return input_bytes
 
     @staticmethod
@@ -149,7 +150,7 @@ class BinaryDecoder(object):
         Bytes are encoded as a long followed by that many bytes of data.
         """
         nbytes = self.read_long()
-        assert (nbytes >= 0), nbytes
+        assert nbytes >= 0, nbytes
         return self.read(nbytes)
 
     def read_utf8(self):
@@ -160,13 +161,13 @@ class BinaryDecoder(object):
         input_bytes = self.read_bytes()
         if PY3:
             try:
-                return input_bytes.decode('utf-8')
+                return input_bytes.decode("utf-8")
             except UnicodeDecodeError as exn:
-                logger.error('Invalid UTF-8 input bytes: %r', input_bytes)
+                logger.error("Invalid UTF-8 input bytes: %r", input_bytes)  # pylint: disable=do-not-log-raised-errors
                 raise exn
         else:
             # PY2
-            return unicode(input_bytes, "utf-8") # pylint: disable=undefined-variable
+            return unicode(input_bytes, "utf-8")  # pylint: disable=undefined-variable
 
     def skip_null(self):
         pass
@@ -216,41 +217,40 @@ class DatumReader(object):
     def set_writer_schema(self, writer_schema):
         self._writer_schema = writer_schema
 
-    writer_schema = property(lambda self: self._writer_schema,
-                             set_writer_schema)
+    writer_schema = property(lambda self: self._writer_schema, set_writer_schema)
 
     def read(self, decoder):
         return self.read_data(self.writer_schema, decoder)
 
     def read_data(self, writer_schema, decoder):
         # function dispatch for reading data based on type of writer's schema
-        if writer_schema.type == 'null':
+        if writer_schema.type == "null":
             result = decoder.read_null()
-        elif writer_schema.type == 'boolean':
+        elif writer_schema.type == "boolean":
             result = decoder.read_boolean()
-        elif writer_schema.type == 'string':
+        elif writer_schema.type == "string":
             result = decoder.read_utf8()
-        elif writer_schema.type == 'int':
+        elif writer_schema.type == "int":
             result = decoder.read_int()
-        elif writer_schema.type == 'long':
+        elif writer_schema.type == "long":
             result = decoder.read_long()
-        elif writer_schema.type == 'float':
+        elif writer_schema.type == "float":
             result = decoder.read_float()
-        elif writer_schema.type == 'double':
+        elif writer_schema.type == "double":
             result = decoder.read_double()
-        elif writer_schema.type == 'bytes':
+        elif writer_schema.type == "bytes":
             result = decoder.read_bytes()
-        elif writer_schema.type == 'fixed':
+        elif writer_schema.type == "fixed":
             result = self.read_fixed(writer_schema, decoder)
-        elif writer_schema.type == 'enum':
+        elif writer_schema.type == "enum":
             result = self.read_enum(writer_schema, decoder)
-        elif writer_schema.type == 'array':
+        elif writer_schema.type == "array":
             result = self.read_array(writer_schema, decoder)
-        elif writer_schema.type == 'map':
+        elif writer_schema.type == "map":
             result = self.read_map(writer_schema, decoder)
-        elif writer_schema.type in ['union', 'error_union']:
+        elif writer_schema.type in ["union", "error_union"]:
             result = self.read_union(writer_schema, decoder)
-        elif writer_schema.type in ['record', 'error', 'request']:
+        elif writer_schema.type in ["record", "error", "request"]:
             result = self.read_record(writer_schema, decoder)
         else:
             fail_msg = f"Cannot read unknown schema type: {writer_schema.type}"
@@ -258,35 +258,35 @@ class DatumReader(object):
         return result
 
     def skip_data(self, writer_schema, decoder):
-        if writer_schema.type == 'null':
+        if writer_schema.type == "null":
             result = decoder.skip_null()
-        elif writer_schema.type == 'boolean':
+        elif writer_schema.type == "boolean":
             result = decoder.skip_boolean()
-        elif writer_schema.type == 'string':
+        elif writer_schema.type == "string":
             result = decoder.skip_utf8()
-        elif writer_schema.type == 'int':
+        elif writer_schema.type == "int":
             result = decoder.skip_int()
-        elif writer_schema.type == 'long':
+        elif writer_schema.type == "long":
             result = decoder.skip_long()
-        elif writer_schema.type == 'float':
+        elif writer_schema.type == "float":
             result = decoder.skip_float()
-        elif writer_schema.type == 'double':
+        elif writer_schema.type == "double":
             result = decoder.skip_double()
-        elif writer_schema.type == 'bytes':
+        elif writer_schema.type == "bytes":
             result = decoder.skip_bytes()
-        elif writer_schema.type == 'fixed':
+        elif writer_schema.type == "fixed":
             result = self.skip_fixed(writer_schema, decoder)
-        elif writer_schema.type == 'enum':
+        elif writer_schema.type == "enum":
             result = self.skip_enum(decoder)
-        elif writer_schema.type == 'array':
+        elif writer_schema.type == "array":
             self.skip_array(writer_schema, decoder)
             result = None
-        elif writer_schema.type == 'map':
+        elif writer_schema.type == "map":
             self.skip_map(writer_schema, decoder)
             result = None
-        elif writer_schema.type in ['union', 'error_union']:
+        elif writer_schema.type in ["union", "error_union"]:
             result = self.skip_union(writer_schema, decoder)
-        elif writer_schema.type in ['record', 'error', 'request']:
+        elif writer_schema.type in ["record", "error", "request"]:
             self.skip_record(writer_schema, decoder)
             result = None
         else:
@@ -389,8 +389,9 @@ class DatumReader(object):
         # schema resolution
         index_of_schema = int(decoder.read_long())
         if index_of_schema >= len(writer_schema.schemas):
-            fail_msg = (f"Can't access branch index {index_of_schema} "
-                        f"for union with {len(writer_schema.schemas)} branches")
+            fail_msg = (
+                f"Can't access branch index {index_of_schema} " f"for union with {len(writer_schema.schemas)} branches"
+            )
             raise SchemaResolutionException(fail_msg, writer_schema)
         selected_writer_schema = writer_schema.schemas[index_of_schema]
 
@@ -400,8 +401,9 @@ class DatumReader(object):
     def skip_union(self, writer_schema, decoder):
         index_of_schema = int(decoder.read_long())
         if index_of_schema >= len(writer_schema.schemas):
-            fail_msg = (f"Can't access branch index {index_of_schema} "
-                        f"for union with {len(writer_schema.schemas)} branches")
+            fail_msg = (
+                f"Can't access branch index {index_of_schema} " f"for union with {len(writer_schema.schemas)} branches"
+            )
             raise SchemaResolutionException(fail_msg, writer_schema)
         return self.skip_data(writer_schema.schemas[index_of_schema], decoder)