azure-storage-blob 12.25.1__py3-none-any.whl → 12.26.0b1__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]
+        :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:
@@ -105,29 +105,25 @@ class BlobQueryReader(object):  # pylint: disable=too-many-instance-attributes
         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]]
+        :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/base_client.py

@@ -131,6 +131,7 @@ class StorageAccountHostsMixin(object):
 
         This could be either the primary endpoint,
         or the secondary endpoint depending on the current :func:`location_mode`.
+
         :returns: The full endpoint URL to this entity, including SAS token if used.
         :rtype: str
         """

azure/storage/blob/_shared/shared_access_signature.py

@@ -41,6 +41,8 @@ class QueryStringConstants(object):
     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'
@@ -78,6 +80,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,

azure/storage/blob/_shared_access_signature.py

@@ -311,7 +311,9 @@ class _BlobSharedAccessHelper(_SharedAccessHelper):
                  self.get_value_to_append(QueryStringConstants.SIGNED_KEY_VERSION) +
                  self.get_value_to_append(QueryStringConstants.SIGNED_AUTHORIZED_OID) +
                  self.get_value_to_append(QueryStringConstants.SIGNED_UNAUTHORIZED_OID) +
-                 self.get_value_to_append(QueryStringConstants.SIGNED_CORRELATION_ID))
+                 self.get_value_to_append(QueryStringConstants.SIGNED_CORRELATION_ID) +
+                 self.get_value_to_append(QueryStringConstants.SIGNED_KEY_DELEGATED_USER_TID) +
+                 self.get_value_to_append(QueryStringConstants.SIGNED_DELEGATED_USER_OID))
         else:
             string_to_sign += self.get_value_to_append(QueryStringConstants.SIGNED_IDENTIFIER)
 

azure/storage/blob/_version.py

@@ -4,4 +4,4 @@
 # license information.
 # --------------------------------------------------------------------------
 
-VERSION = "12.25.1"
+VERSION = "12.26.0b1"

azure/storage/blob/aio/_blob_client_async.py

@@ -9,7 +9,8 @@ import warnings
 from datetime import datetime
 from functools import partial
 from typing import (
-    Any, AnyStr, AsyncIterable, cast, Dict, IO, Iterable, List, Optional, overload, Tuple, Union,
+    Any, AnyStr, AsyncIterable, Callable, cast, Dict, IO,
+    Iterable, List, Optional, overload, Tuple, Union,
     TYPE_CHECKING
 )
 from typing_extensions import Self
@@ -23,6 +24,7 @@ from azure.core.tracing.decorator_async import distributed_trace_async
 from ._download_async import StorageStreamDownloader
 from ._lease_async import BlobLeaseClient
 from ._models import PageRangePaged
+from ._quick_query_helper_async import BlobQueryReader
 from ._upload_helpers import (
     upload_append_blob,
     upload_block_blob,
@@ -46,6 +48,7 @@ from .._blob_client_helpers import (
     _get_block_list_result,
     _get_page_ranges_options,
     _parse_url,
+    _quick_query_options,
     _resize_blob_options,
     _seal_append_blob_options,
     _set_blob_metadata_options,
@@ -69,21 +72,27 @@ from .._deserialize import (
 from .._encryption import StorageEncryptionMixin, _ERROR_UNSUPPORTED_METHOD_FOR_ENCRYPTION
 from .._generated.aio import AzureBlobStorage
 from .._generated.models import CpkInfo
-from .._models import BlobType, BlobBlock, BlobProperties, PageRange
+from .._models import BlobType, BlobBlock, BlobProperties, BlobQueryError, PageRange
 from .._serialize import get_access_conditions, get_api_version, get_modify_conditions, get_version_id
 from .._shared.base_client_async import AsyncStorageAccountHostsMixin, AsyncTransportWrapper, parse_connection_str
 from .._shared.policies_async import ExponentialRetry
 from .._shared.response_handlers import process_storage_error, return_response_headers
 
 if TYPE_CHECKING:
+    from azure.core import MatchConditions
     from azure.core.credentials import AzureNamedKeyCredential, AzureSasCredential
     from azure.core.credentials_async import AsyncTokenCredential
     from azure.core.pipeline.policies import AsyncHTTPPolicy
+    from azure.storage.blob import CustomerProvidedEncryptionKey
     from azure.storage.blob.aio import ContainerClient
     from .._models import (
+        ArrowDialect,
         ContentSettings,
+        DelimitedJsonDialect,
+        DelimitedTextDialect,
         ImmutabilityPolicy,
         PremiumPageBlobTier,
+        QuickQueryDialect,
         SequenceNumberAction,
         StandardBlobTier
     )
@@ -412,6 +421,15 @@ class BlobClient(AsyncStorageAccountHostsMixin, StorageAccountHostsMixin, Storag
         :keyword str source_authorization:
             Authenticate as a service principal using a client secret to access a source blob. Ensure "bearer " is
             the prefix of the source_authorization string.
+        :keyword source_token_intent:
+            Required when source is Azure Storage Files and using `TokenCredential` for authentication.
+            This is ignored for other forms of authentication.
+            Specifies the intent for all requests when using `TokenCredential` authentication. Possible values are:
+
+            backup - Specifies requests are intended for backup/admin type operations, meaning that all file/directory
+                 ACLs are bypassed and full permissions are granted. User must also have required RBAC permission.
+
+        :paramtype source_token_intent: Literal['backup']
         :returns: Response from creating a new block blob for a given URL.
         :rtype: Dict[str, Any]
         """
@@ -420,7 +438,8 @@ class BlobClient(AsyncStorageAccountHostsMixin, StorageAccountHostsMixin, Storag
         options = _upload_blob_from_url_options(
             source_url=source_url,
             metadata=metadata,
-            **kwargs)
+            **kwargs
+        )
         try:
             return cast(Dict[str, Any], await self._client.block_blob.put_blob_from_url(**options))
         except HttpResponseError as error:
@@ -746,6 +765,133 @@ class BlobClient(AsyncStorageAccountHostsMixin, StorageAccountHostsMixin, Storag
         await downloader._setup()  # pylint: disable=protected-access
         return downloader
 
+    @distributed_trace_async
+    async def query_blob(
+        self, query_expression: str,
+        *,
+        on_error: Optional[Callable[[BlobQueryError], None]] = None,
+        blob_format: Optional[Union["DelimitedTextDialect", "DelimitedJsonDialect", "QuickQueryDialect", str]] = None,
+        output_format: Optional[Union["DelimitedTextDialect", "DelimitedJsonDialect", "QuickQueryDialect", List["ArrowDialect"], str]] = None,  # pylint: disable=line-too-long
+        lease: Optional[Union[BlobLeaseClient, str]] = None,
+        if_modified_since: Optional[datetime] = None,
+        if_unmodified_since: Optional[datetime] = None,
+        etag: Optional[str] = None,
+        match_condition: Optional["MatchConditions"] = None,
+        if_tags_match_condition: Optional[str] = None,
+        cpk: Optional["CustomerProvidedEncryptionKey"] = None,
+        timeout: Optional[int] = None,
+        **kwargs: Any
+    ) -> BlobQueryReader:
+        """Enables users to select/project on blob/or blob snapshot data by providing simple query expressions.
+        This operation returns a BlobQueryReader, users need to use readall() or readinto() to get query data.
+
+        :param str query_expression:
+            Required. a query statement. For more details see
+            https://learn.microsoft.com/azure/storage/blobs/query-acceleration-sql-reference.
+        :keyword Callable[~azure.storage.blob.BlobQueryError] on_error:
+            A function to be called on any processing errors returned by the service.
+        :keyword blob_format:
+            Optional. Defines the serialization of the data currently stored in the blob. The default is to
+            treat the blob data as CSV data formatted in the default dialect. This can be overridden with
+            a custom DelimitedTextDialect, or DelimitedJsonDialect or "ParquetDialect" (passed as a string or enum).
+            These dialects can be passed through their respective classes, the QuickQueryDialect enum or as a string.
+
+            .. note::
+                "ParquetDialect" is in preview, so some features may not work as intended.
+
+        :paramtype blob_format:
+            ~azure.storage.blob.DelimitedTextDialect or
+            ~azure.storage.blob.DelimitedJsonDialect or
+            ~azure.storage.blob.QuickQueryDialect or
+            str
+        :keyword output_format:
+            Optional. Defines the output serialization for the data stream. By default the data will be returned
+            as it is represented in the blob (Parquet formats default to DelimitedTextDialect).
+            By providing an output format, the blob data will be reformatted according to that profile.
+            This value can be a DelimitedTextDialect or a DelimitedJsonDialect or ArrowDialect.
+            These dialects can be passed through their respective classes, the QuickQueryDialect enum or as a string.
+        :paramtype output_format:
+            ~azure.storage.blob.DelimitedTextDialect or
+            ~azure.storage.blob.DelimitedJsonDialect or
+            ~azure.storage.blob.QuickQueryDialect or
+            List[~azure.storage.blob.ArrowDialect] or
+            str
+        :keyword lease:
+            Required if the blob has an active lease. Value can be a BlobLeaseClient object
+            or the lease ID as a string.
+        :keyword ~datetime.datetime if_modified_since:
+            A DateTime value. Azure expects the date value passed in to be UTC.
+            If timezone is included, any non-UTC datetime will be converted to UTC.
+            If a date is passed in without timezone info, it is assumed to be UTC.
+            Specify this header to perform the operation only if
+            the resource has been modified since the specified date/time.
+        :keyword ~datetime.datetime if_unmodified_since:
+            A DateTime value. Azure expects the date value passed in to be UTC.
+            If timezone is included, any non-UTC datetime will be converted to UTC.
+            If a date is passed in without timezone info, it is assumed to be UTC.
+            Specify this header to perform the operation only if
+            the resource has not been modified since the specified date/time.
+        :keyword str etag:
+            An ETag value, or the wildcard character (*). Used to check if the resource has changed,
+            and act according to the condition specified by the `match_condition` parameter.
+        :keyword ~azure.core.MatchConditions match_condition:
+            The match condition to use upon the etag.
+        :keyword str if_tags_match_condition:
+            Specify a SQL where clause on blob tags to operate only on blob with a matching value.
+            eg. ``\"\\\"tagname\\\"='my tag'\"``
+
+            .. versionadded:: 12.4.0
+
+        :keyword ~azure.storage.blob.CustomerProvidedEncryptionKey cpk:
+            Encrypts the data on the service-side with the given key.
+            Use of customer-provided keys must be done over HTTPS.
+            As the encryption key itself is provided in the request,
+            a secure connection must be established to transfer the key.
+        :keyword int timeout:
+            Sets the server-side timeout for the operation in seconds. For more details see
+            https://learn.microsoft.com/rest/api/storageservices/setting-timeouts-for-blob-service-operations.
+            This value is not tracked or validated on the client. To configure client-side network timeouts
+            see `here <https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/storage/azure-storage-blob
+            #other-client--per-operation-configuration>`__.
+        :returns: A streaming object (BlobQueryReader)
+        :rtype: ~azure.storage.blob.aio.BlobQueryReader
+        """
+        error_cls = kwargs.pop("error_cls", BlobQueryError)
+        encoding = kwargs.pop("encoding", None)
+        if cpk and self.scheme.lower() != 'https':
+            raise ValueError("Customer provided encryption key must be used over HTTPS.")
+        options, delimiter = _quick_query_options(
+            self.snapshot,
+            query_expression,
+            blob_format=blob_format,
+            output_format=output_format,
+            lease=lease,
+            if_modified_since=if_modified_since,
+            if_unmodified_since=if_unmodified_since,
+            etag=etag,
+            match_condition=match_condition,
+            if_tags_match_condition=if_tags_match_condition,
+            cpk=cpk,
+            timeout=timeout,
+            **kwargs
+        )
+        try:
+            headers, raw_response_body = await self._client.blob.query(**options)
+        except HttpResponseError as error:
+            process_storage_error(error)
+        blob_query_reader = BlobQueryReader(
+            name=self.blob_name,
+            container=self.container_name,
+            errors=on_error,
+            record_delimiter=delimiter,
+            encoding=encoding,
+            headers=headers,
+            response=raw_response_body,
+            error_cls=error_cls
+        )
+        await blob_query_reader._setup()  # pylint: disable=protected-access
+        return blob_query_reader
+
     @distributed_trace_async
     async def delete_blob(self, delete_snapshots: Optional[str] = None, **kwargs: Any) -> None:
         """Marks the specified blob for deletion.
@@ -1650,6 +1796,15 @@ class BlobClient(AsyncStorageAccountHostsMixin, StorageAccountHostsMixin, Storag
 
             .. versionadded:: 12.9.0
 
+        :keyword source_token_intent:
+            Required when source is Azure Storage Files and using `TokenCredential` for authentication.
+            This is ignored for other forms of authentication.
+            Specifies the intent for all requests when using `TokenCredential` authentication. Possible values are:
+
+            backup - Specifies requests are intended for backup/admin type operations, meaning that all file/directory
+                 ACLs are bypassed and full permissions are granted. User must also have required RBAC permission.
+
+        :paramtype source_token_intent: Literal['backup']
         :keyword str encryption_scope:
             A predefined encryption scope used to encrypt the data on the sync copied blob. An encryption
             scope can be created using the Management API and referenced here by name. If a default
@@ -1674,7 +1829,8 @@ class BlobClient(AsyncStorageAccountHostsMixin, StorageAccountHostsMixin, Storag
             source_url=source_url,
             metadata=metadata,
             incremental_copy=incremental_copy,
-            **kwargs)
+            **kwargs
+        )
         try:
             if incremental_copy:
                 return cast(Dict[str, Union[str, datetime]], await self._client.page_blob.copy_incremental(**options))
@@ -1944,6 +2100,15 @@ class BlobClient(AsyncStorageAccountHostsMixin, StorageAccountHostsMixin, Storag
         :keyword str source_authorization:
             Authenticate as a service principal using a client secret to access a source blob. Ensure "bearer " is
             the prefix of the source_authorization string.
+        :keyword source_token_intent:
+            Required when source is Azure Storage Files and using `TokenCredential` for authentication.
+            This is ignored for other forms of authentication.
+            Specifies the intent for all requests when using `TokenCredential` authentication. Possible values are:
+
+            backup - Specifies requests are intended for backup/admin type operations, meaning that all file/directory
+                 ACLs are bypassed and full permissions are granted. User must also have required RBAC permission.
+
+        :paramtype source_token_intent: Literal['backup']
         :returns: Blob property dict.
         :rtype: Dict[str, Any]
         """
@@ -1955,7 +2120,8 @@ class BlobClient(AsyncStorageAccountHostsMixin, StorageAccountHostsMixin, Storag
             source_offset=source_offset,
             source_length=source_length,
             source_content_md5=source_content_md5,
-            **kwargs)
+            **kwargs
+        )
         try:
             return cast(Dict[str, Any], await self._client.block_blob.stage_block_from_url(**options))
         except HttpResponseError as error:
@@ -2819,6 +2985,15 @@ class BlobClient(AsyncStorageAccountHostsMixin, StorageAccountHostsMixin, Storag
         :keyword str source_authorization:
             Authenticate as a service principal using a client secret to access a source blob. Ensure "bearer " is
             the prefix of the source_authorization string.
+        :keyword source_token_intent:
+            Required when source is Azure Storage Files and using `TokenCredential` for authentication.
+            This is ignored for other forms of authentication.
+            Specifies the intent for all requests when using `TokenCredential` authentication. Possible values are:
+
+            backup - Specifies requests are intended for backup/admin type operations, meaning that all file/directory
+                 ACLs are bypassed and full permissions are granted. User must also have required RBAC permission.
+
+        :paramtype source_token_intent: Literal['backup']
         :returns: Response after uploading pages from specified URL.
         :rtype: Dict[str, Any]
         """
@@ -3112,6 +3287,15 @@ class BlobClient(AsyncStorageAccountHostsMixin, StorageAccountHostsMixin, Storag
         :keyword str source_authorization:
             Authenticate as a service principal using a client secret to access a source blob. Ensure "bearer " is
             the prefix of the source_authorization string.
+        :keyword source_token_intent:
+            Required when source is Azure Storage Files and using `TokenCredential` for authentication.
+            This is ignored for other forms of authentication.
+            Specifies the intent for all requests when using `TokenCredential` authentication. Possible values are:
+
+            backup - Specifies requests are intended for backup/admin type operations, meaning that all file/directory
+                 ACLs are bypassed and full permissions are granted. User must also have required RBAC permission.
+
+        :paramtype source_token_intent: Literal['backup']
         :returns: Result after appending a new block.
         :rtype: Dict[str, Union[str, datetime, int]]
         """

azure/storage/blob/aio/_quick_query_helper_async.py

@@ -0,0 +1,194 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+
+from io import BytesIO
+from typing import (
+    Any, AsyncGenerator, AsyncIterable, Dict, IO, Optional, Type,
+    TYPE_CHECKING
+)
+
+from .._shared.avro.avro_io_async import AsyncDatumReader
+from .._shared.avro.datafile_async import AsyncDataFileReader
+
+if TYPE_CHECKING:
+    from .._models import BlobQueryError
+
+
+class BlobQueryReader:  # pylint: disable=too-many-instance-attributes
+    """A streaming object to read query results."""
+
+    name: str
+    """The name of the blob being queried."""
+    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: 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
+        self.record_delimiter = record_delimiter
+        self._size = 0
+        self._bytes_processed = 0
+        self._errors = errors
+        self._encoding = encoding
+        self._parsed_results = AsyncDataFileReader(QuickQueryStreamer(response), AsyncDatumReader())
+        self._error_cls = error_cls
+
+    async def _setup(self):
+        self._parsed_results = await self._parsed_results.init()
+        first_result = await self._parsed_results.__anext__()
+        self._first_result = self._process_record(first_result)  # pylint: disable=attribute-defined-outside-init
+
+    def __len__(self) -> int:
+        return self._size
+
+    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:
+            return result.get('data')
+        if 'fatal' in result:
+            error = self._error_cls(
+                error=result['name'],
+                is_fatal=result['fatal'],
+                description=result['description'],
+                position=result['position']
+            )
+            if self._errors:
+                self._errors(error)
+        return None
+
+    async def _aiter_stream(self) -> AsyncGenerator[bytes, None]:
+        if self._first_result is not None:
+            yield self._first_result
+        async for next_result in self._parsed_results:
+            processed_result = self._process_record(next_result)
+            if processed_result is not None:
+                yield processed_result
+
+    async def readall(self) -> bytes:
+        """Return all query results.
+
+        This operation is blocking until all data is downloaded.
+
+        :returns: The query results.
+        :rtype: bytes
+        """
+        stream = BytesIO()
+        await self.readinto(stream)
+        data = stream.getvalue()
+        if self._encoding:
+            return data.decode(self._encoding)  # type: ignore [return-value]
+        return data
+
+    async def readinto(self, stream: IO) -> None:
+        """Download the query result to a stream.
+
+        :param IO stream:
+            The stream to download to. This can be an open file-handle,
+            or any writable stream.
+        :returns: None
+        """
+        async for record in self._aiter_stream():
+            stream.write(record)
+
+    async def records(self) -> AsyncIterable[bytes]:
+        """Returns a record generator for the query result.
+
+        Records will be returned line by line.
+
+        :returns: A record generator for the query result.
+        :rtype: AsyncIterable[bytes]
+        """
+        delimiter = self.record_delimiter.encode('utf-8')
+        async for record_chunk in self._aiter_stream():
+            for record in record_chunk.split(delimiter):
+                if self._encoding:
+                    yield record.decode(self._encoding)  # type: ignore [misc]
+                else:
+                    yield record
+
+
+class QuickQueryStreamer:
+    """File-like streaming iterator."""
+
+    def __init__(self, generator):
+        self.generator = generator
+        self.iterator = generator.__aiter__()
+        self._buf = b""
+        self._point = 0
+        self._download_offset = 0
+        self._buf_start = 0
+        self.file_length = None
+
+    def __len__(self):
+        return self.file_length
+
+    def __aiter__(self):
+        return self.iterator
+
+    @staticmethod
+    def seekable():
+        return True
+
+    async def __anext__(self):
+        next_part = await self.iterator.__anext__()
+        self._download_offset += len(next_part)
+        return next_part
+
+    def tell(self):
+        return self._point
+
+    async def seek(self, offset, whence=0):
+        if whence == 0:
+            self._point = offset
+        elif whence == 1:
+            self._point += offset
+        else:
+            raise ValueError("whence must be 0 or 1")
+        if self._point < 0:  # pylint: disable=consider-using-max-builtin
+            self._point = 0
+
+    async def read(self, size):
+        try:
+            # keep reading from the generator until the buffer of this stream has enough data to read
+            while self._point + size > self._download_offset:
+                self._buf += await self.__anext__()
+        except StopAsyncIteration:
+            self.file_length = self._download_offset
+
+        start_point = self._point
+
+        # EOF
+        self._point = min(self._point + size, self._download_offset)
+
+        relative_start = start_point - self._buf_start
+        if relative_start < 0:
+            raise ValueError("Buffer has dumped too much data")
+        relative_end = relative_start + size
+        data = self._buf[relative_start:relative_end]
+
+        # dump the extra data in buffer
+        # buffer start--------------------16bytes----current read position
+        dumped_size = max(relative_end - 16 - relative_start, 0)
+        self._buf_start += dumped_size
+        self._buf = self._buf[dumped_size:]
+
+        return data

{azure_storage_blob-12.25.1.dist-info → azure_storage_blob-12.26.0b1.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: azure-storage-blob
-Version: 12.25.1
+Version: 12.26.0b1
 Summary: Microsoft Azure Blob Storage Client Library for Python
 Home-page: https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/storage/azure-storage-blob
 Author: Microsoft Corporation
 Author-email: ascl@microsoft.com
 License: MIT License
 Keywords: azure,azure sdk
-Classifier: Development Status :: 5 - Production/Stable
+Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3