miniopy-async 1.23.2__tar.gz → 1.23.4__tar.gz

{miniopy_async-1.23.2 → miniopy_async-1.23.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: miniopy-async
-Version: 1.23.2
+Version: 1.23.4
 Summary: Asynchronous MinIO Client SDK for Python
 Home-page: https://github.com/hlf20010508/miniopy-async
 License: Apache-2.0

{miniopy_async-1.23.2 → miniopy_async-1.23.4}/miniopy_async/__init__.py

@@ -36,7 +36,7 @@ miniopy-async - Asynchronous MinIO Client SDK for Python
 
 __title__ = "miniopy-async"
 __author__ = "L-ING"
-__version__ = "1.23.2"
+__version__ = "1.23.4"
 __license__ = "Apache 2.0"
 __copyright__ = "(C) 2022 L-ING <hlf01@icloud.com>"
 

{miniopy_async-1.23.2 → miniopy_async-1.23.4}/miniopy_async/api.py

@@ -29,13 +29,14 @@ import ssl
 import tarfile
 from collections.abc import Iterable
 from datetime import datetime, timedelta
-from io import BytesIO
+from io import BytesIO, IOBase
 from random import random
 from typing import Any, AsyncGenerator, BinaryIO, TextIO, cast
 from urllib.parse import urlunsplit
 from xml.etree import ElementTree as ET
 
 import certifi
+import yarl
 from aiohttp import ClientResponse, ClientSession, ClientTimeout, TCPConnector
 from aiohttp.typedefs import LooseHeaders
 from aiohttp_retry import ExponentialRetry, RetryClient
@@ -54,6 +55,7 @@ from .datatypes import (
     ListMultipartUploadsResult,
     ListObjects,
     ListPartsResult,
+    MultipartUploader,
     Object,
     Part,
     PostPolicy,
@@ -72,7 +74,6 @@ from .helpers import (
     DictType,
     ObjectWriteResult,
     ProgressType,
-    Substream,
     check_bucket_name,
     check_object_name,
     check_sse,
@@ -84,6 +85,7 @@ from .helpers import (
     makedirs,
     md5sum_hash,
     queryencode,
+    read_part_data,
     sha256_hash,
 )
 from .legalhold import LegalHold
@@ -265,7 +267,7 @@ class Minio:  # pylint: disable=too-many-public-methods
         self,
         host: str,
         headers: LooseHeaders | DictType | None,
-        body: bytes | BytesIO | Substream | None,
+        body: bytes | BinaryIO | None,
         creds: Credentials | None,
     ) -> tuple[dict[str, str], datetime]:
         """Build headers with given parameters."""
@@ -279,10 +281,13 @@ class Minio:  # pylint: disable=too-many-public-methods
         if body:
             if isinstance(body, BytesIO):
                 headers["Content-Length"] = str(body.getbuffer().nbytes)
-            elif isinstance(body, Substream):
-                headers["Content-Length"] = str(body.size)
-            else:
+            elif isinstance(body, IOBase):
+                stat = os.fstat(body.fileno())
+                headers["Content-Length"] = str(stat.st_size)
+            elif isinstance(body, bytes):
                 headers["Content-Length"] = str(len(body))
+            else:
+                raise ValueError("body must be bytes or BinaryIO type")
         if creds:
             if self._base_url.is_https:
                 sha256 = "UNSIGNED-PAYLOAD"
@@ -307,7 +312,7 @@ class Minio:  # pylint: disable=too-many-public-methods
         region: str,
         bucket_name: str | None = None,
         object_name: str | None = None,
-        body: bytes | BytesIO | Substream | None = None,
+        body: bytes | BinaryIO | None = None,
         headers: LooseHeaders | DictType | None = None,
         query_params: DictType | None = None,
         no_body_trace: bool = False,
@@ -361,9 +366,10 @@ class Minio:  # pylint: disable=too-many-public-methods
         self._ensure_session()
         session = cast(ClientSession | RetryClient, self._session)
 
+        yarl_url = yarl.URL(urlunsplit(url), encoded=True)
         response = await session.request(
             method,
-            urlunsplit(url),
+            yarl_url,
             data=body,
             headers=http_headers,
         )
@@ -498,7 +504,7 @@ class Minio:  # pylint: disable=too-many-public-methods
         method: str,
         bucket_name: str | None = None,
         object_name: str | None = None,
-        body: bytes | BytesIO | Substream | None = None,
+        body: bytes | BinaryIO | None = None,
         headers: DictType | None = None,
         query_params: DictType | None = None,
         no_body_trace: bool = False,
@@ -2296,11 +2302,140 @@ class Minio:  # pylint: disable=too-many-public-methods
         element = ET.fromstring(await response.text())
         return cast(str, findtext(element, "UploadId", True))
 
+    def multipart_uploader(
+        self,
+        bucket_name: str,
+        object_name: str,
+        content_type: str = "application/octet-stream",
+        metadata: DictType | None = None,
+        sse: Sse | None = None,
+        tags: Tags | None = None,
+        retention: Retention | None = None,
+        legal_hold: bool = False,
+        extra_headers: DictType | None = None,
+    ) -> MultipartUploader:
+        """
+        Create a multipart uploader for large data.
+
+        :param str bucket_name: Name of the bucket.
+        :param str object_name: Object name in the bucket.
+        :param str content_type: Content type of the object.
+        :param DictType | None metadata: Any additional metadata to be uploaded along
+            with your PUT request.
+        :param Sse | None sse: Server-side encryption.
+        :param Tags | None tags: :class:`Tags` for the object.
+        :param Retention | None retention: :class:`Retention` configuration object.
+        :param bool legal_hold: Flag to set legal hold for the object.
+        :param DictType | None extra_headers: Any additional headers to be added with GET request.
+        :return: :class:`MultipartUploader` object.
+        :rtype: MultipartUploader
+
+        .. code-block:: python
+
+            import asyncio
+
+            from miniopy_async import Minio
+
+            client = Minio(
+                "play.min.io",
+                access_key="Q3AM3UQ867SPQQA43P2F",
+                secret_key="zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG",
+                secure=True,  # http for False, https for True
+            )
+
+
+            async def main():
+                # Use context manager
+                print("example one")
+                async with client.multipart_uploader(
+                    "my-bucket",
+                    "my-object",
+                ) as uploader:
+                    await uploader.upload_part(b"hello" * 1024 * 1024, 1)
+                    await uploader.upload_part(b"world", 2)
+                result = uploader.result
+                print(
+                    "created {0} object; etag: {1}, version-id: {2}".format(
+                        result.object_name,
+                        result.etag,
+                        result.version_id,
+                    ),
+                )
+
+                # Use directly
+                print("example two")
+                uploader = client.multipart_uploader(
+                    "my-bucket",
+                    "my-object",
+                )
+                await uploader.upload_part(b"hello" * 1024 * 1024, 1)
+                await uploader.upload_part(b"world", 2)
+                result = await uploader.complete()
+                print(
+                    "created {0} object; etag: {1}, version-id: {2}".format(
+                        result.object_name,
+                        result.etag,
+                        result.version_id,
+                    ),
+                )
+
+                # Abort
+                print("example three")
+                uploader = client.multipart_uploader(
+                    "my-bucket",
+                    "my-object",
+                )
+                await uploader.upload_part(b"hello", 1)
+                await uploader.abort()
+
+                # Parallel upload
+                print("example four")
+                tasks = []
+                async with client.multipart_uploader(
+                    "my-bucket",
+                    "my-object",
+                ) as uploader:
+                    for i in range(1, 11):
+                        data = (f"part{i}" * 1024 * 1024).encode("utf-8")
+                        tasks.append(uploader.upload_part(data, i))
+                    await asyncio.gather(*tasks)
+                result = uploader.result
+                print(
+                    "created {0} object; etag: {1}, version-id: {2}".format(
+                        result.object_name,
+                        result.etag,
+                        result.version_id,
+                    ),
+                )
+
+
+            asyncio.run(main())
+        """
+        check_bucket_name(bucket_name, s3_check=self._base_url.is_aws_host)
+        check_object_name(object_name)
+        check_sse(sse)
+        if tags is not None and not isinstance(tags, Tags):
+            raise ValueError("tags must be Tags type")
+        if retention is not None and not isinstance(retention, Retention):
+            raise ValueError("retention must be Retention type")
+
+        headers = genheaders(metadata, sse, tags, retention, legal_hold)
+        headers["Content-Type"] = content_type or "application/octet-stream"
+        if extra_headers:
+            headers.update(extra_headers)
+
+        return MultipartUploader(
+            self,
+            bucket_name,
+            object_name,
+            headers,
+        )
+
     async def _put_object(
         self,
         bucket_name: str,
         object_name: str,
-        data: Substream,
+        data: bytes | BinaryIO,
         headers: DictType | None,
         query_params: DictType | None = None,
     ) -> ObjectWriteResult:
@@ -2326,7 +2461,7 @@ class Minio:  # pylint: disable=too-many-public-methods
         self,
         bucket_name: str,
         object_name: str,
-        data: Substream,
+        data: bytes | BytesIO,
         headers: DictType | None,
         upload_id: str,
         part_number: int,
@@ -2371,13 +2506,14 @@ class Minio:  # pylint: disable=too-many-public-methods
         tags: Tags | None = None,
         retention: Retention | None = None,
         legal_hold: bool = False,
+        write_offset: int | None = None,
     ) -> ObjectWriteResult:
         """
         Uploads data from a stream to an object in a bucket.
 
         :param str bucket_name: Name of the bucket.
         :param str object_name: Object name in the bucket.
-        :param BinaryIO | FileIOWrapperBase data: An object having callable read() returning bytes object.
+        :param BinaryIO data: An object having callable read() returning bytes object.
         :param int length: Data size; -1 for unknown size and set valid part_size.
         :param str content_type: Content type of the object.
         :param DictType | None metadata: Any additional metadata to be uploaded along
@@ -2389,6 +2525,7 @@ class Minio:  # pylint: disable=too-many-public-methods
         :param Tags | None tags: :class:`Tags` for the object.
         :param Retention | None retention: :class:`Retention` configuration object.
         :param bool legal_hold: Flag to set legal hold for the object.
+        :param int | None write_offset: Offset byte for appending data to existing object.
         :return: :class:`ObjectWriteResult` object.
         :rtype: ObjectWriteResult
         :raise ValueError: If tags is not of type :class:`Tags`.
@@ -2493,14 +2630,31 @@ class Minio:  # pylint: disable=too-many-public-methods
             raise ValueError("retention must be Retention type")
         if not callable(getattr(data, "read")):
             raise ValueError("input data must have callable read()")
+        if write_offset is not None:
+            if write_offset < 0:
+                raise ValueError("write offset should not be negative")
+            if length < 0:
+                raise ValueError("length must be provided for write offset")
+            part_size = length if length > MIN_PART_SIZE else MIN_PART_SIZE
+
+        headers = genheaders(metadata, sse, tags, retention, legal_hold)
+        headers["Content-Type"] = content_type or "application/octet-stream"
+        if write_offset:
+            headers["x-amz-write-offset-bytes"] = str(write_offset)
+
+        if part_size == length:
+            return await self._put_object(
+                bucket_name,
+                object_name,
+                data,
+                headers,
+            )
+
         part_size, part_count = get_part_info(length, part_size)
         if progress:
             # Set progress bar length and object name before upload
             await progress.set_meta(object_name=object_name, total_length=length)
 
-        headers = genheaders(metadata, sse, tags, retention, legal_hold)
-        headers["Content-Type"] = content_type or "application/octet-stream"
-
         object_size = length
         uploaded_size = 0
         part_number = 0
@@ -2517,26 +2671,22 @@ class Minio:  # pylint: disable=too-many-public-methods
                     if part_number == part_count:
                         part_size = object_size - uploaded_size
                         stop = True
-                    part_data = Substream(data, uploaded_size, part_size)
-                    if part_data.size != part_size:
+                    part_data = await read_part_data(data, part_size, progress=progress)
+                    if len(part_data) != part_size:
                         raise IOError(
                             f"stream having not enough data;"
                             f"expected: {part_size}, "
-                            f"got: {part_data.size} bytes"
+                            f"got: {len(part_data)} bytes"
                         )
                 else:
-                    part_data = Substream(data, uploaded_size, part_size)
-                    if part_data.size == 0:
+                    part_data = await read_part_data(data, part_size, progress=progress)
+                    if len(part_data) == 0:
                         break
-                    if part_data.size < part_size:
+                    if len(part_data) < part_size:
                         part_count = part_number
                         stop = True
-                        part_size = part_data.size
-
-                if progress:
-                    await progress.update(part_size)
 
-                uploaded_size += part_size
+                uploaded_size += len(part_data)
 
                 if part_count == 1:
                     return await self._put_object(
@@ -2606,6 +2756,169 @@ class Minio:  # pylint: disable=too-many-public-methods
                 )
             raise exc
 
+    async def append_object(
+        self,
+        bucket_name: str,
+        object_name: str,
+        data: BinaryIO,
+        length: int,
+        chunk_size: int | None = None,
+        progress: ProgressType | None = None,
+        extra_headers: DictType | None = None,
+    ) -> ObjectWriteResult:
+        """
+        Appends from a stream to existing object in a bucket.
+
+        :param str bucket_name: Name of the bucket.
+        :param str object_name: Object name in the bucket.
+        :param BinaryIO data: An object having callable read() returning bytes object.
+        :param int length: Data size; -1 for unknown size.
+        :param int chunk_size: Chunk size to optimize uploads.
+        :param ProgressType | None progress: A progress object.
+        :param DictType | None extra_headers: Any additional headers to be added with GET request.
+        :return: :class:`ObjectWriteResult` object.
+        :rtype: ObjectWriteResult
+        :raise ValueError: If length is 0.
+        :raise ValueError: If chunk_size is less than 5 MiB or greater than 5 GiB.
+        :raise IOError: If stream doesn't have enough data to read.
+
+        .. code-block:: python
+
+            import asyncio
+            import io
+            from urllib.request import urlopen
+
+            from miniopy_async import Minio
+
+            client = Minio(
+                "play.min.io",
+                access_key="Q3AM3UQ867SPQQA43P2F",
+                secret_key="zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG",
+                secure=True,  # http for False, https for True
+            )
+
+
+            async def main():
+                # Upload data.
+                result = await client.put_object(
+                    "my-bucket",
+                    "my-object",
+                    io.BytesIO(b"hello, "),
+                    7,
+                )
+                print(f"created {result.object_name} object; etag: {result.etag}")
+
+                # Append data.
+                result = await client.append_object(
+                    "my-bucket",
+                    "my-object",
+                    io.BytesIO(b"world"),
+                    5,
+                )
+                print(f"appended {result.object_name} object; etag: {result.etag}")
+
+                # Append data in chunks.
+                data = urlopen(
+                    "https://www.kernel.org/pub/linux/kernel/v6.x/linux-6.13.12.tar.xz",
+                )
+                result = await client.append_object(
+                    "my-bucket",
+                    "my-object",
+                    data,
+                    148611164,
+                    5 * 1024 * 1024,
+                )
+                print(f"appended {result.object_name} object; etag: {result.etag}")
+
+                # Append unknown sized data.
+                data = urlopen(
+                    "https://www.kernel.org/pub/linux/kernel/v6.x/linux-6.14.3.tar.xz",
+                )
+                result = await client.append_object(
+                    "my-bucket",
+                    "my-object",
+                    data,
+                    149426584,
+                    5 * 1024 * 1024,
+                )
+                print(f"appended {result.object_name} object; etag: {result.etag}")
+
+
+            asyncio.run(main())
+        """
+        if length == 0:
+            raise ValueError("length should not be zero")
+        if chunk_size is not None:
+            if chunk_size < MIN_PART_SIZE:
+                raise ValueError("chunk size must be minimum of 5 MiB")
+            if chunk_size > MAX_PART_SIZE:
+                raise ValueError("chunk size must be less than 5 GiB")
+        else:
+            chunk_size = length if length > MIN_PART_SIZE else MIN_PART_SIZE
+
+        chunk_count = -1
+        if length > 0:
+            chunk_count = int(length / chunk_size)
+            if (chunk_count * chunk_size) < length:
+                chunk_count += 1
+            chunk_count = chunk_count or 1
+
+        object_size = length
+        uploaded_size = 0
+        chunk_number = 0
+        stop = False
+
+        stat = await self.stat_object(bucket_name, object_name)
+        write_offset = cast(int, stat.size)
+        upload_result = None
+
+        while not stop:
+            chunk_number += 1
+            if chunk_count > 0:
+                if chunk_number == chunk_count:
+                    chunk_size = object_size - uploaded_size
+                    stop = True
+                chunk_data = await read_part_data(
+                    data, cast(int, chunk_size), progress=progress
+                )
+                if len(chunk_data) != chunk_size:
+                    raise IOError(
+                        f"stream having not enough data;"
+                        f"expected: {chunk_size}, "
+                        f"got: {len(chunk_data)} bytes"
+                    )
+            else:
+                chunk_data = await read_part_data(
+                    data, cast(int, chunk_size), progress=progress
+                )
+                if len(chunk_data) == 0:
+                    break
+                if len(chunk_data) < chunk_size:
+                    chunk_count = chunk_number
+                    stop = True
+
+            uploaded_size += len(chunk_data)
+
+            headers = extra_headers or {}
+            headers["x-amz-write-offset-bytes"] = str(write_offset)
+            upload_result = await self._put_object(
+                bucket_name,
+                object_name,
+                chunk_data,
+                headers=headers,
+            )
+            write_offset += chunk_size
+
+        upload_result = cast(ObjectWriteResult, upload_result)
+        return ObjectWriteResult(
+            cast(str, upload_result.bucket_name),
+            cast(str, upload_result.object_name),
+            upload_result.version_id,
+            upload_result.etag,
+            upload_result.http_headers,
+            location=upload_result.location,
+        )
+
     def list_objects(
         self,
         bucket_name: str,
@@ -4228,9 +4541,10 @@ class Minio:  # pylint: disable=too-many-public-methods
         metadata["X-Amz-Meta-Snowball-Auto-Extract"] = "true"
 
         name = staging_filename
-        mode = "w:gz" if compression else "w"
         fileobj = None if name else BytesIO()
-        with tarfile.open(name=name, mode=mode, fileobj=fileobj) as tar:
+        with tarfile.open(
+            name=name, mode="w:gz" if compression else "w", fileobj=fileobj
+        ) as tar:
             for obj in object_list:
                 if obj.filename:
                     tar.add(obj.filename, obj.object_name)

{miniopy_async-1.23.2 → miniopy_async-1.23.4}/miniopy_async/datatypes.py

@@ -21,6 +21,7 @@ Response of ListBuckets, ListObjects, ListObjectsV2 and ListObjectVersions API.
 from __future__ import absolute_import, annotations
 
 import base64
+import io
 import itertools
 import json
 from collections import OrderedDict
@@ -1286,3 +1287,100 @@ class DeleteErrors:
         async for error in self:
             errors.append(error)
         return errors
+
+
+class MultipartUploader:
+    def __init__(
+        self,
+        client: Minio,
+        bucket_name: str,
+        object_name: str,
+        headers: DictType,
+    ):
+        self._client = client
+        self._bucket_name = bucket_name
+        self._object_name = object_name
+        self._headers = headers
+        self._upload_id = ""
+        self._parts = []
+        self._result: CompleteMultipartUploadResult | None = None
+
+    @property
+    def result(self) -> CompleteMultipartUploadResult:
+        """
+        Get multipart upload result.
+
+        :return: Multipart upload result.
+        :rtype: CompleteMultipartUploadResult
+        :raises ValueError: If multipart upload is not completed.
+        """
+        if not self._result:
+            raise ValueError("Multipart upload not completed")
+        return self._result
+
+    async def _init(self):
+        self._upload_id = await self._client._create_multipart_upload(
+            self._bucket_name, self._object_name, self._headers
+        )
+
+    async def complete(self) -> CompleteMultipartUploadResult:
+        """
+        Complete multipart upload.
+
+        :return: Multipart upload result.
+        :rtype: CompleteMultipartUploadResult
+        """
+        self._result = await self._client._complete_multipart_upload(
+            self._bucket_name, self._object_name, self._upload_id, self._parts
+        )
+        return self.result
+
+    async def abort(self):
+        """Abort multipart upload."""
+        await self._client._abort_multipart_upload(
+            self._bucket_name, self._object_name, self._upload_id
+        )
+
+    async def __aenter__(self):
+        await self._init()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.complete()
+
+    async def upload_part(self, data: bytes | io.BytesIO, part_number: int) -> Part:
+        """
+        Upload a part of the object.
+
+        The data size must be larger than 5 MiB and less than 5 GiB except the last part.
+
+        :param bytes | io.BytesIO data: Data to upload as part.
+        :param int part_number: Number of the part.
+        :return: Part information.
+        :rtype: Part
+        :raises ValueError: If part_number is not a positive integer.
+        """
+        if not self._upload_id:
+            await self._init()
+        try:
+            if not isinstance(part_number, int) or part_number < 1:
+                raise ValueError("part_number must be a positive integer")
+
+            etag = await self._client._upload_part(
+                self._bucket_name,
+                self._object_name,
+                data,
+                self._headers,
+                self._upload_id,
+                part_number,
+            )
+
+            part = Part(part_number, etag)
+            self._parts.append(part)
+
+            return part
+
+        except Exception as e:
+            await self.abort()
+
+            raise e

{miniopy_async-1.23.2 → miniopy_async-1.23.4}/miniopy_async/error.py

@@ -170,10 +170,3 @@ class MinioAdminException(Exception):
 
     def __reduce__(self):
         return type(self), (self._code, self._body)
-
-
-class UnreachableError(MinioException):
-    """Raised when unreachable code reached."""
-
-    def __init__(self):
-        super().__init__("unreachable code reached, please report this issue.")

{miniopy_async-1.23.2 → miniopy_async-1.23.4}/miniopy_async/helpers.py

@@ -18,6 +18,7 @@
 
 from __future__ import absolute_import, annotations, division, unicode_literals
 
+import asyncio
 import base64
 import errno
 import hashlib
@@ -32,8 +33,6 @@ from typing import BinaryIO, Dict, List, Protocol, Tuple, Union
 
 from aiohttp.typedefs import LooseHeaders
 
-from miniopy_async.error import UnreachableError
-
 from . import __title__, __version__
 from .sse import Sse, SseCustomerKey
 from .time import to_iso8601utc
@@ -209,6 +208,31 @@ class ProgressType(Protocol):
         """Set current progress length."""
 
 
+async def read_part_data(
+    stream: BinaryIO,
+    size: int,
+    progress: ProgressType | None = None,
+) -> bytes:
+    """Read part data of given size from stream."""
+    if not callable(getattr(stream, "read")):
+        raise ValueError("stream must have callable read()")
+
+    part_data = b""
+    while size:
+        data = stream.read(size)
+        if asyncio.iscoroutine(data):
+            data = await data
+        if not data:
+            break  # EOF reached
+        if not isinstance(data, bytes):
+            raise ValueError("read() must return 'bytes' object")
+        part_data += data
+        size -= len(data)
+        if progress:
+            await progress.update(len(data))
+    return part_data
+
+
 def makedirs(path: str):
     """Wrapper of os.makedirs() ignores errno.EEXIST."""
     try:
@@ -307,7 +331,7 @@ def check_sse(sse: Sse | None):
         raise ValueError("Sse type is required")
 
 
-def md5sum_hash(data: str | bytes | BinaryIO | Substream | None) -> str | None:
+def md5sum_hash(data: str | bytes | BinaryIO | None) -> str | None:
     """Compute MD5 of data and return hash as Base64 encoded value."""
     if data is None:
         return None
@@ -320,7 +344,7 @@ def md5sum_hash(data: str | bytes | BinaryIO | Substream | None) -> str | None:
     )
     if isinstance(data, (str, bytes)):
         hasher.update(data.encode() if isinstance(data, str) else data)
-    elif isinstance(data, (io.BytesIO, Substream)) and data.readable():
+    elif isinstance(data, (io.BytesIO, io.IOBase)) and data.readable():
         pos = data.tell()
         data.seek(0)
 
@@ -341,13 +365,13 @@ def md5sum_hash(data: str | bytes | BinaryIO | Substream | None) -> str | None:
     return md5sum.decode()
 
 
-def sha256_hash(data: str | bytes | BinaryIO | Substream | None) -> str:
+def sha256_hash(data: str | bytes | BinaryIO | None) -> str:
     """Compute SHA-256 of data and return hash as hex encoded value."""
     data = data or b""
     hasher = hashlib.sha256()
     if isinstance(data, (str, bytes)):
         hasher.update(data.encode() if isinstance(data, str) else data)
-    elif isinstance(data, (io.BytesIO, Substream)) and data.readable():
+    elif isinstance(data, (io.BytesIO, io.IOBase)) and data.readable():
         pos = data.tell()
         data.seek(0)
 
@@ -856,126 +880,3 @@ class ObjectWriteResult:
     def location(self) -> str | None:
         """Get location."""
         return self._location
-
-
-class Substream(io.IOBase):
-    def __init__(self, base: BinaryIO, offset: int, part_size: int):
-        if not (hasattr(base, "read") and hasattr(base, "seek")):
-            raise TypeError("Base object must support read() and seek()")
-
-        self._base = base
-        self._start = offset
-        self._size = self._get_size(part_size)
-        self._pos = 0
-        self._closed = False
-
-    def _get_size(self, part_size: int) -> int:
-        """Get size of the substream using bisection."""
-        head = self._start
-        tail = self._start + part_size - 1
-
-        self._base.seek(tail)
-        data = self._base.read(1)
-        if data:
-            return part_size
-
-        self._base.seek(head)
-        data = self._base.read(1)
-        if not data:
-            return 0
-
-        # bisection
-        while tail >= head:
-            center = (head + tail) // 2
-            self._base.seek(center)
-            data = self._base.read(2)
-            if not data:
-                tail = center - 1
-            elif len(data) == 2:
-                head = center + 1
-            else:
-                return center - self._start + 1
-
-        raise UnreachableError
-
-    @property
-    def size(self) -> int:
-        """Get size of the substream."""
-        return self._size
-
-    def read(self, size: int = -1) -> bytes:
-        """Read data from the substream."""
-        self._check_closed()
-        self._base.seek(self._start + self._pos)
-
-        remaining = self._size - self._pos
-        if remaining <= 0:
-            return b""
-        if size < 0 or size > remaining:
-            size = remaining
-        data = self._base.read(size)
-        self._pos += len(data)
-        return data
-
-    def is_empty(self) -> bool:
-        """Check if the substream is empty."""
-        pos = self._pos
-
-        self.seek(0)
-        if not self.read(1):
-            return True
-
-        self._pos = pos
-        return False
-
-    def seek(self, offset: int, whence: int = io.SEEK_SET) -> int:
-        """Seek to a position in the substream."""
-        if whence == io.SEEK_SET:
-            new_pos = offset
-        elif whence == io.SEEK_CUR:
-            new_pos = self._pos + offset
-        elif whence == io.SEEK_END:
-            new_pos = self._size + offset
-        else:
-            raise ValueError(f"Invalid whence: {whence!r}")
-
-        if not 0 <= new_pos <= self._size:
-            raise ValueError("seek position out of range")
-
-        self._pos = new_pos
-        return self._pos
-
-    def tell(self) -> int:
-        """Return the current position in the substream."""
-        self._check_closed()
-        return self._pos
-
-    def readable(self) -> bool:
-        """Check if the substream is readable."""
-        return True
-
-    def seekable(self) -> bool:
-        """Check if the substream is seekable."""
-        return True
-
-    def close(self) -> None:
-        self._closed = True
-
-    @property
-    def closed(self) -> bool:
-        return self._closed
-
-    def _check_closed(self) -> None:
-        if self._closed:
-            raise ValueError("I/O operation on closed file.")
-
-    def __enter__(self):
-        self._check_closed()
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self.close()
-
-    def remaining(self) -> int:
-        """Bytes left to read."""
-        return max(0, self._size - self._pos)

{miniopy_async-1.23.2 → miniopy_async-1.23.4}/miniopy_async/minioadmin.py

@@ -55,6 +55,7 @@ from .signer import sign_v4_s3
 class _COMMAND(Enum):
     """Admin Command enumerations."""
 
+    ACCOUNT_INFO = "accountinfo"
     ADD_USER = "add-user"
     USER_INFO = "user-info"
     LIST_USERS = "list-users"
@@ -324,6 +325,15 @@ class MinioAdmin:
         )
         return await response.text()
 
+    async def account_info(self, prefix_usage: bool = False) -> str:
+        """Get usage information for the authenticating account"""
+        response = await self._url_open(
+            "GET",
+            _COMMAND.ACCOUNT_INFO,
+            query_params={"prefix-usage": "true"} if prefix_usage else None,
+        )
+        return await response.text()
+
     async def user_add(self, access_key: str, secret_key: str) -> str:
         """Create user with access and secret keys"""
         body = json.dumps({"status": "enabled", "secretKey": secret_key}).encode()

{miniopy_async-1.23.2 → miniopy_async-1.23.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "miniopy-async"
-version = "1.23.2"
+version = "1.23.4"
 description = "Asynchronous MinIO Client SDK for Python"
 authors = [
     "L-ING <hlf01@icloud.com>",