hexkit 7.3.0__tar.gz → 8.0.0__tar.gz

{hexkit-7.3.0/src/hexkit.egg-info → hexkit-8.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hexkit
-Version: 7.3.0
+Version: 8.0.0
 Summary: A Toolkit for Building Microservices using the Hexagonal Architecture
 Author-email: "German Human Genome Phenome Archive (GHGA)" <contact@ghga.de>
 License: Apache 2.0

{hexkit-7.3.0 → hexkit-8.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [build-system]
 requires = [
-    "setuptools>=80.9",
+    "setuptools>=80.10",
 ]
 build-backend = "setuptools.build_meta"
 
@@ -23,7 +23,7 @@ classifiers = [
     "Intended Audience :: Developers",
 ]
 name = "hexkit"
-version = "7.3.0"
+version = "8.0.0"
 description = "A Toolkit for Building Microservices using the Hexagonal Architecture"
 dependencies = [
     "opentelemetry-api >=1.39, <2",
@@ -221,7 +221,7 @@ check_untyped_defs = true
 no_site_packages = false
 
 [tool.pytest.ini_options]
-minversion = "8.4"
+minversion = "9.0"
 asyncio_mode = "strict"
 asyncio_default_fixture_loop_scope = "function"
 

{hexkit-7.3.0 → hexkit-8.0.0}/src/hexkit/protocols/dao.py

@@ -23,7 +23,7 @@ from abc import ABC, abstractmethod
 from collections.abc import AsyncIterator, Collection, Mapping
 from contextlib import AbstractAsyncContextManager
 from functools import partial
-from typing import Any, TypeVar
+from typing import Any, Generic, TypeVar
 from uuid import uuid4
 
 from pydantic import BaseModel, Field
@@ -39,10 +39,22 @@ __all__ = [
     "ResourceAlreadyExistsError",
     "ResourceNotFoundError",
     "UUID4Field",
+    "UniqueConstraintViolationError",
 ]
 
+
+class IndexBase(ABC):
+    """Base from which all DAO index classes must inherit"""
+
+    @abstractmethod
+    def list_field_names(self) -> list[str]:
+        """Returns a list of all fields specified by this index"""
+        ...
+
+
 # Type variable for handling Data Transfer Objects:
 Dto = TypeVar("Dto", bound=BaseModel)
+Index = TypeVar("Index", bound=IndexBase)
 
 
 class DaoError(RuntimeError):
@@ -65,6 +77,20 @@ class ResourceAlreadyExistsError(DaoError):
         super().__init__(message)
 
 
+class UniqueConstraintViolationError(DaoError):
+    """Raised when attempting to insert a resource violated a uniqueness constraint.
+
+    This does not apply to the default unique index automatically applied to
+    the ID field.
+    """
+
+    def __init__(self, *, unique_fields: dict[str, Any]):
+        message = (
+            f"A resource with the unique field value(s) {unique_fields} already exists."
+        )
+        super().__init__(message)
+
+
 class FindError(DaoError):
     """Base for all error related to DAO find operations."""
 
@@ -268,16 +294,19 @@ class DaoFactoryBase:
         cls,
         *,
         dto_model: type[Dto],
-        fields_to_index: Collection[str] | None,
+        indexes: Collection[Index] | None,
     ) -> None:
         """Checks that all provided fields are present in the dto_model.
         Raises IndexFieldsInvalidError otherwise.
         """
-        if fields_to_index is None:
+        if not indexes:
             return
 
         try:
-            validate_fields_in_model(model=dto_model, fields=fields_to_index)
+            for index in indexes:
+                validate_fields_in_model(
+                    model=dto_model, fields=index.list_field_names()
+                )
         except FieldNotInModelError as error:
             raise cls.IndexFieldsInvalidError(
                 f"Provided index fields are invalid: {error}"
@@ -289,16 +318,14 @@ class DaoFactoryBase:
         *,
         dto_model: type[Dto],
         id_field: str,
-        fields_to_index: Collection[str] | None,
+        indexes: Collection[Index] | None,
     ) -> None:
         """Validates the input parameters of the get_dao method."""
         cls._validate_dto_model_id(dto_model=dto_model, id_field=id_field)
-        cls._validate_fields_to_index(
-            dto_model=dto_model, fields_to_index=fields_to_index
-        )
+        cls._validate_fields_to_index(dto_model=dto_model, indexes=indexes)
 
 
-class DaoFactoryProtocol(DaoFactoryBase, ABC):
+class DaoFactoryProtocol(DaoFactoryBase, ABC, Generic[Index]):
     """A protocol describing a factory to produce Data Access Objects (DAO) objects
     that are enclosed in transactional scopes.
     """
@@ -309,7 +336,7 @@ class DaoFactoryProtocol(DaoFactoryBase, ABC):
         name: str,
         dto_model: type[Dto],
         id_field: str,
-        fields_to_index: Collection[str] | None = None,
+        indexes: Collection[Index] | None = None,
     ) -> Dao[Dto]:
         """Constructs a DAO for interacting with resources in a database.
 
@@ -322,9 +349,9 @@ class DaoFactoryProtocol(DaoFactoryBase, ABC):
             id_field:
                 The name of the field of the `dto_model` that serves as resource ID.
                 (DAO implementation might use this field as primary key.)
-            fields_to_index:
-                Optionally, provide any fields that should be indexed in addition to the
-                `id_field`. Defaults to None.
+            indexes:
+                Optionally, provide any indexes that should be created in addition to
+                the provider's default index on `id_field`. Defaults to None.
         Returns:
             A DAO specific to the provided DTO model.
 
@@ -334,17 +361,13 @@ class DaoFactoryProtocol(DaoFactoryBase, ABC):
             self.IdTypeNotSupportedError:
                 Raised when the id_field of the dto_model has an unexpected type.
         """
-        self._validate(
-            dto_model=dto_model,
-            id_field=id_field,
-            fields_to_index=fields_to_index,
-        )
+        self._validate(dto_model=dto_model, id_field=id_field, indexes=indexes)
 
         return await self._get_dao(
             name=name,
             dto_model=dto_model,
             id_field=id_field,
-            fields_to_index=fields_to_index,
+            indexes=indexes,
         )
 
     @abstractmethod
@@ -354,7 +377,7 @@ class DaoFactoryProtocol(DaoFactoryBase, ABC):
         name: str,
         dto_model: type[Dto],
         id_field: str,
-        fields_to_index: Collection[str] | None,
+        indexes: Collection[Index] | None,
     ) -> Dao[Dto]:
         """*To be implemented by the provider. Input validation is done outside of this
         method.*

{hexkit-7.3.0 → hexkit-8.0.0}/src/hexkit/protocols/daopub.py

@@ -26,11 +26,7 @@ from abc import ABC, abstractmethod
 from collections.abc import Callable, Collection
 
 from hexkit.custom_types import JsonObject
-from hexkit.protocols.dao import (
-    Dao,
-    DaoFactoryBase,
-    Dto,
-)
+from hexkit.protocols.dao import Dao, DaoFactoryBase, Dto, Index
 
 
 class DaoPublisher(Dao[Dto], typing.Protocol[Dto]):
@@ -49,7 +45,7 @@ class DaoPublisher(Dao[Dto], typing.Protocol[Dto]):
         ...
 
 
-class DaoPublisherFactoryProtocol(DaoFactoryBase, ABC):
+class DaoPublisherFactoryProtocol(DaoFactoryBase, ABC, typing.Generic[Index]):
     """A protocol describing a factory to produce Data Access Objects (DAO) objects
     which automatically publish changes according to the outbox pattern.
     """
@@ -60,7 +56,7 @@ class DaoPublisherFactoryProtocol(DaoFactoryBase, ABC):
         name: str,
         dto_model: type[Dto],
         id_field: str,
-        fields_to_index: Collection[str] | None = None,
+        indexes: Collection[Index] | None = None,
         dto_to_event: Callable[[Dto], JsonObject | None],
         event_topic: str,
         autopublish: bool = True,
@@ -76,9 +72,9 @@ class DaoPublisherFactoryProtocol(DaoFactoryBase, ABC):
             id_field:
                 The name of the field of the `dto_model` that serves as resource ID.
                 (DAO implementation might use this field as primary key.)
-            fields_to_index:
-                Optionally, provide any fields that should be indexed in addition to the
-                `id_field`. Defaults to None.
+            indexes:
+                Optionally, provide any indexes that should be created in addition to
+                the provider's default index on `id_field`. Defaults to None.
             dto_to_event:
                 A function that takes a DTO and returns the payload for an event.
                 If the returned payload is None, the event will not be published.
@@ -97,17 +93,13 @@ class DaoPublisherFactoryProtocol(DaoFactoryBase, ABC):
             self.IdTypeNotSupportedError:
                 Raised when the id_field of the dto_model has an unexpected type.
         """
-        self._validate(
-            dto_model=dto_model,
-            id_field=id_field,
-            fields_to_index=fields_to_index,
-        )
+        self._validate(dto_model=dto_model, id_field=id_field, indexes=indexes)
 
         return await self._get_dao(
             name=name,
             dto_model=dto_model,
             id_field=id_field,
-            fields_to_index=fields_to_index,
+            indexes=indexes,
             dto_to_event=dto_to_event,
             event_topic=event_topic,
             autopublish=autopublish,
@@ -120,7 +112,7 @@ class DaoPublisherFactoryProtocol(DaoFactoryBase, ABC):
         name: str,
         dto_model: type[Dto],
         id_field: str,
-        fields_to_index: Collection[str] | None,
+        indexes: Collection[Index] | None,
         dto_to_event: Callable[[Dto], JsonObject | None],
         event_topic: str,
         autopublish: bool,

{hexkit-7.3.0 → hexkit-8.0.0}/src/hexkit/protocols/objstorage.py

@@ -182,6 +182,31 @@ class ObjectStorageProtocol(ABC):
             anticipated_part_size=anticipated_part_size,
         )
 
+    async def list_multipart_uploads_for_object(
+        self, *, bucket_id: str, object_id: str
+    ) -> list[str]:
+        """Lists all active multipart uploads for the given object ID.
+
+        Raises a `BucketNotFoundError` if the bucket does not exist.
+        """
+        self._validate_bucket_id(bucket_id)
+        self._validate_object_id(object_id)
+        return await self._list_multipart_uploads_for_object(
+            bucket_id=bucket_id, object_id=object_id
+        )
+
+    async def get_all_multipart_uploads(self, *, bucket_id: str) -> dict[str, str]:
+        """Gets all active multipart uploads for the given bucket ID.
+
+        Returns a dict where the keys are upload IDs and values are object IDs.
+        S3 allows multiple ongoing multi-part uploads, so it's possible for some upload
+        IDs to map to the same object ID.
+
+        Raises a `BucketNotFoundError` if the bucket does not exist.
+        """
+        self._validate_bucket_id(bucket_id)
+        return await self._get_all_multipart_uploads(bucket_id=bucket_id)
+
     async def get_object_download_url(
         self, *, bucket_id: str, object_id: str, expires_after: int = 86400
     ) -> str:
@@ -404,6 +429,29 @@ class ObjectStorageProtocol(ABC):
         """
         ...
 
+    @abstractmethod
+    async def _list_multipart_uploads_for_object(
+        self, *, bucket_id: str, object_id: str
+    ) -> list[str]:
+        """Lists all active multipart uploads for the given object ID.
+
+        *To be implemented by the provider. Input validation is done outside of this
+        method.*
+        """
+        ...
+
+    @abstractmethod
+    async def _get_all_multipart_uploads(self, *, bucket_id: str) -> dict[str, str]:
+        """Gets all active multipart uploads for the given bucket ID.
+
+        Returns a dict where the keys are upload IDs and values are object IDs.
+        S3 allows multiple ongoing multi-part uploads, so it's possible for some upload
+        IDs to map to the same object ID.
+
+        *To be implemented by the provider. Input validation is done outside of this
+        method.*
+        """
+
     @abstractmethod
     async def _get_object_download_url(
         self, *, bucket_id: str, object_id: str, expires_after: int = 86400

{hexkit-7.3.0 → hexkit-8.0.0}/src/hexkit/providers/mongodb/__init__.py

@@ -23,6 +23,7 @@ from .provider import (
     MongoDbDao,
     MongoDbDaoFactory,
     MongoDbDtoKeyValueStore,
+    MongoDbIndex,
     MongoDbJsonKeyValueStore,
     MongoDbStrKeyValueStore,
     translate_pymongo_errors,
@@ -35,6 +36,7 @@ __all__ = [
     "MongoDbDao",
     "MongoDbDaoFactory",
     "MongoDbDtoKeyValueStore",
+    "MongoDbIndex",
     "MongoDbJsonKeyValueStore",
     "MongoDbStrKeyValueStore",
     "translate_pymongo_errors",

{hexkit-7.3.0 → hexkit-8.0.0}/src/hexkit/providers/mongodb/provider/__init__.py

@@ -23,6 +23,7 @@ from .client import ConfiguredMongoClient
 from .dao import (
     MongoDbDao,
     MongoDbDaoFactory,
+    MongoDbIndex,
     get_single_hit,
     replace_id_field_in_find_mapping,
     validate_find_mapping,
@@ -41,6 +42,7 @@ __all__ = [
     "MongoDbDao",
     "MongoDbDaoFactory",
     "MongoDbDtoKeyValueStore",
+    "MongoDbIndex",
     "MongoDbJsonKeyValueStore",
     "MongoDbStrKeyValueStore",
     "document_to_dto",

{hexkit-7.3.0 → hexkit-8.0.0}/src/hexkit/providers/mongodb/provider/dao.py

@@ -22,7 +22,7 @@ Utilities for testing are located in `./testutils.py`.
 from collections.abc import AsyncIterator, Callable, Collection, Mapping
 from contextlib import AbstractAsyncContextManager, asynccontextmanager
 from functools import partial
-from typing import Any, Generic
+from typing import Any, Generic, Literal, TypeAlias
 
 from pymongo import AsyncMongoClient
 from pymongo.asynchronous.collection import AsyncCollection
@@ -33,11 +33,13 @@ from hexkit.protocols.dao import (
     Dao,
     DaoFactoryProtocol,
     Dto,
+    IndexBase,
     InvalidFindMappingError,
     MultipleHitsFoundError,
     NoHitsFoundError,
     ResourceAlreadyExistsError,
     ResourceNotFoundError,
+    UniqueConstraintViolationError,
 )
 from hexkit.providers.mongodb.config import MongoDbConfig
 from hexkit.providers.mongodb.provider.client import ConfiguredMongoClient
@@ -51,6 +53,7 @@ from hexkit.utils import FieldNotInModelError, validate_fields_in_model
 __all__ = [
     "MongoDbDao",
     "MongoDbDaoFactory",
+    "MongoDbIndex",
     "get_single_hit",
     "replace_id_field_in_find_mapping",
     "validate_find_mapping",
@@ -113,6 +116,67 @@ async def get_single_hit(
     raise MultipleHitsFoundError(mapping=mapping)
 
 
+FieldName: TypeAlias = str
+SortOrder: TypeAlias = Literal[1] | Literal[-1]
+
+
+class MongoDbIndex(IndexBase):
+    """Information required to apply a single MongoDbIndex."""
+
+    fields: dict[FieldName, SortOrder]
+    properties: dict[str, Any] | None = None
+
+    def __init__(
+        self,
+        *,
+        fields: FieldName | dict[FieldName, SortOrder],
+        properties: dict[str, Any] | None = None,
+    ):
+        """Initialize the index.
+
+        **Args**
+        - `fields`: a single field name or a dict containing the field name and the sort
+            order. For sort order, 1 means ascending and -1 means descending. If the index
+            covers the model's `id_field`, then specify the actual field name instead of
+            "_id". When passing a field name instead of a dict, ascending sort order is used.
+        - `properties`: a dictionary where the keys are MongoDB index property names, and
+            the values are the value to pass for that property.
+
+        More information on index creation with Pymongo, including a list of the supported
+        index properties, can be found [here](https://pymongo.readthedocs.io/en/stable/api/pymongo/collection.html#pymongo.collection.Collection.create_index)
+
+        Example:
+        ```python
+        # This creates a compound unique index over field_a and field_b.
+        MongoDbIndex(
+            fields={"field_a": 1, "field_b": -1},
+            properties={"unique": True}
+        )
+
+        # This creates an ascending-sorted index over field_a.
+        MongoDbIndex("field_a")
+        ```
+        """
+        if isinstance(fields, str):
+            self.fields = {fields: 1}
+        else:
+            self.fields = fields
+
+        self.properties = properties
+
+    def list_field_names(self) -> list[str]:
+        """Return a list of all the field names contained in this index"""
+        return list(self.fields)
+
+    def fields_with_id_replaced(
+        self, id_field: str
+    ) -> str | list[tuple[FieldName, SortOrder]]:
+        """Returns the `fields` property with all instances of `id_field`
+        replaced with `"_id"`.
+        """
+        return [("_id" if f == id_field else f, so) for f, so in self.fields.items()]
+
+
 class MongoDbDao(Generic[Dto]):
     """A MongoDb-specific DAO."""
 
@@ -295,6 +359,11 @@ class MongoDbDao(Generic[Dto]):
             try:
                 await self._collection.insert_one(document)
             except DuplicateKeyError as error:
+                key_value = error.details.get("keyValue")  # type: ignore
+                if key_value is not None and list(key_value) != ["_id"]:
+                    raise UniqueConstraintViolationError(
+                        unique_fields=key_value
+                    ) from error
                 raise ResourceAlreadyExistsError(id_=document["_id"]) from error
 
     async def upsert(self, dto: Dto) -> None:
@@ -312,7 +381,7 @@ class MongoDbDao(Generic[Dto]):
             )
 
 
-class MongoDbDaoFactory(DaoFactoryProtocol):
+class MongoDbDaoFactory(DaoFactoryProtocol[MongoDbIndex]):
     """A MongoDB-based provider implementing the DaoFactoryProtocol."""
 
     @classmethod
@@ -354,7 +423,7 @@ class MongoDbDaoFactory(DaoFactoryProtocol):
         name: str,
         dto_model: type[Dto],
         id_field: str,
-        fields_to_index: Collection[str] | None,
+        indexes: Collection[MongoDbIndex] | None = None,
     ) -> Dao[Dto]:
         """Constructs a DAO for interacting with resources in a MongoDB database.
 
@@ -366,13 +435,14 @@ class MongoDbDaoFactory(DaoFactoryProtocol):
         from the database server. Thus for compliance with the DaoFactoryProtocol, this
         method is async.
         """
-        if fields_to_index is not None:
-            raise NotImplementedError(
-                "Indexing on non-ID fields has not been implemented, yet."
-            )
-
         collection = self._db[name]
 
+        for index in indexes or []:
+            properties = index.properties or {}
+            await collection.create_index(
+                index.fields_with_id_replaced(id_field=id_field), **properties
+            )
+
         return MongoDbDao(
             collection=collection,
             dto_model=dto_model,

{hexkit-7.3.0 → hexkit-8.0.0}/src/hexkit/providers/mongokafka/provider/daopub.py

@@ -45,6 +45,7 @@ from hexkit.providers.mongodb.provider import (
     translate_pymongo_errors,
     validate_find_mapping,
 )
+from hexkit.providers.mongodb.provider.dao import MongoDbIndex
 from hexkit.providers.mongokafka.config import MongoKafkaConfig
 
 
@@ -437,7 +438,7 @@ class MongoKafkaDaoPublisher(Generic[Dto]):
             await self.publish_document(document)
 
 
-class MongoKafkaDaoPublisherFactory(DaoPublisherFactoryProtocol):
+class MongoKafkaDaoPublisherFactory(DaoPublisherFactoryProtocol[MongoDbIndex]):
     """A provider implementing the DaoPublisherFactoryProtocol based on MongoDB and
     Apache Kafka.
     """
@@ -491,7 +492,7 @@ class MongoKafkaDaoPublisherFactory(DaoPublisherFactoryProtocol):
         name: str,
         dto_model: type[Dto],
         id_field: str,
-        fields_to_index: Collection[str] | None,
+        indexes: Collection[MongoDbIndex] | None,
         dto_to_event: Callable[[Dto], JsonObject | None],
         event_topic: str,
         autopublish: bool,
@@ -502,13 +503,14 @@ class MongoKafkaDaoPublisherFactory(DaoPublisherFactoryProtocol):
         Please see the DaoPublisherFactoryProtocol superclass for documentation of
         parameters.
         """
-        if fields_to_index is not None:
-            raise NotImplementedError(
-                "Indexing on non-ID fields has not been implemented, yet."
-            )
-
         collection = self._db[name]
 
+        for index in indexes or []:
+            properties = index.properties or {}
+            await collection.create_index(
+                index.fields_with_id_replaced(id_field=id_field), **properties
+            )
+
         dao = MongoDbDao(
             collection=collection,
             dto_model=dto_model,

{hexkit-7.3.0 → hexkit-8.0.0}/src/hexkit/providers/s3/provider.py

@@ -401,15 +401,17 @@ class S3ObjectStorage(ObjectStorageProtocol):
             url=presigned_url["url"], fields=presigned_url["fields"]
         )
 
-    async def _list_multipart_upload_for_object(
+    async def _list_multipart_uploads_for_object(
         self, *, bucket_id: str, object_id: str
     ) -> list[str]:
-        """Lists all active multipart uploads for the given object. Returns a list of
-        their IDs.
+        """Lists all active multipart uploads for the given object ID.
 
-        (S3 allows multiple ongoing multi-part uploads.)
+        Raises a `BucketNotFoundError` if the bucket does not exist.
+
+        Boto3 Documentation:
+        https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/s3/client/list_multipart_uploads.html#S3.Client.list_multipart_uploads
         """
-        uploads = []
+        uploads: list[str] = []
         try:
             response_iter = await asyncio.to_thread(
                 self._client.get_paginator("list_multipart_uploads").paginate,
@@ -430,9 +432,38 @@ class S3ObjectStorage(ObjectStorageProtocol):
 
         return uploads
 
+    async def _get_all_multipart_uploads(self, *, bucket_id: str) -> dict[str, str]:
+        """Gets all active multipart uploads for the given bucket ID.
+
+        Returns a dict where the keys are upload IDs and values are object IDs.
+        S3 allows multiple ongoing multi-part uploads, so it's possible for some upload
+        IDs to map to the same object ID.
+
+        Raises a `BucketNotFoundError` if the bucket does not exist.
+        """
+        uploads: dict[str, str] = {}
+        try:
+            response_iter = await asyncio.to_thread(
+                self._client.get_paginator("list_multipart_uploads").paginate,
+                Bucket=bucket_id,
+            )
+            for response_page in response_iter:
+                uploads.update(
+                    {
+                        upload["UploadId"]: upload["Key"]
+                        for upload in response_page.get("Uploads", [])
+                    }
+                )
+        except botocore.exceptions.ClientError as error:
+            raise self._translate_s3_client_errors(
+                error, bucket_id=bucket_id
+            ) from error
+
+        return uploads
+
     async def _assert_no_multipart_upload(self, *, bucket_id: str, object_id: str):
         """Ensure that there are no active multi-part uploads for the given object."""
-        upload_ids = await self._list_multipart_upload_for_object(
+        upload_ids = await self._list_multipart_uploads_for_object(
             bucket_id=bucket_id, object_id=object_id
         )
         if len(upload_ids) > 0:
@@ -454,14 +485,14 @@ class S3ObjectStorage(ObjectStorageProtocol):
         By default, also verifies that this upload is the only upload active for
         that file. Otherwise, raises MultipleActiveUploadsError.
         """
-        upload_ids = await self._list_multipart_upload_for_object(
+        upload_ids = await self._list_multipart_uploads_for_object(
             bucket_id=bucket_id, object_id=object_id
         )
         n_uploads = len(upload_ids)
 
         if assert_exclusiveness and n_uploads > 1:
             raise self.MultipleActiveUploadsError(
-                bucket_id=bucket_id, object_id=object_id, upload_ids=upload_ids
+                bucket_id=bucket_id, object_id=object_id, upload_ids=list(upload_ids)
             )
 
         if upload_id not in upload_ids:
@@ -877,12 +908,12 @@ class S3ObjectStorage(ObjectStorageProtocol):
                 # There should only be one ongoing multipart upload/copy at at a time as long
                 # as a new object ID is generated for each attempt
                 try:
-                    upload_ids = await self._list_multipart_upload_for_object(
+                    upload_ids = await self._list_multipart_uploads_for_object(
                         bucket_id=dest_bucket_id, object_id=dest_object_id
                     )
                     if len(upload_ids) == 1:
                         await self._abort_multipart_upload(
-                            upload_id=upload_ids[0],
+                            upload_id=next(iter(upload_ids)),
                             bucket_id=dest_bucket_id,
                             object_id=dest_object_id,
                         )

{hexkit-7.3.0 → hexkit-8.0.0}/src/hexkit/providers/testing/s3.py

@@ -168,6 +168,32 @@ class InMemObjectStorage(ObjectStorageProtocol):
         uploads_for_object = self.uploads[bucket_id].get(object_id, set())
         return sorted(uploads_for_object)
 
+    async def _list_multipart_uploads_for_object(
+        self, *, bucket_id: str, object_id: str
+    ) -> list[str]:
+        """Lists all active multipart uploads for the given object ID.
+
+        Raises a `BucketNotFoundError` if the bucket does not exist.
+        """
+        await self._assert_bucket_exists(bucket_id)
+        return list(self.uploads[bucket_id].get(object_id, set()))
+
+    async def _get_all_multipart_uploads(self, *, bucket_id: str) -> dict[str, str]:
+        """Gets all active multipart uploads for the given bucket ID.
+
+        Returns a dict where the keys are upload IDs and values are object IDs.
+        S3 allows multiple ongoing multi-part uploads, so it's possible for some upload
+        IDs to map to the same object ID.
+
+        Raises a `BucketNotFoundError` if the bucket does not exist.
+        """
+        await self._assert_bucket_exists(bucket_id)
+        return {
+            upload_id: object_id
+            for object_id, uploads in self.uploads[bucket_id].items()
+            for upload_id in uploads
+        }
+
     async def _assert_no_multipart_upload(self, *, bucket_id: str, object_id: str):
         """Ensure that there are no active multi-part uploads for the given object.
 

{hexkit-7.3.0 → hexkit-8.0.0/src/hexkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hexkit
-Version: 7.3.0
+Version: 8.0.0
 Summary: A Toolkit for Building Microservices using the Hexagonal Architecture
 Author-email: "German Human Genome Phenome Archive (GHGA)" <contact@ghga.de>
 License: Apache 2.0