hexkit 3.5.0__tar.gz → 3.7.0__tar.gz

{hexkit-3.5.0/src/hexkit.egg-info → hexkit-3.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hexkit
-Version: 3.5.0
+Version: 3.7.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-3.5.0 → hexkit-3.7.0}/pyproject.toml

@@ -23,7 +23,7 @@ classifiers = [
     "Intended Audience :: Developers",
 ]
 name = "hexkit"
-version = "3.5.0"
+version = "3.7.0"
 description = "A Toolkit for Building Microservices using the Hexagonal Architecture"
 dependencies = [
     "pydantic >=2, <3",

{hexkit-3.5.0 → hexkit-3.7.0}/src/hexkit/config.py

@@ -143,7 +143,7 @@ def config_from_yaml(
                 model_config = SettingsConfigDict(frozen=True, env_prefix=f"{prefix}_")
 
                 @classmethod
-                def settings_customise_sources(  # noqa: PLR0913
+                def settings_customise_sources(
                     cls,
                     settings_cls: type[BaseSettings],
                     init_settings: PydanticBaseSettingsSource,

{hexkit-3.5.0 → hexkit-3.7.0}/src/hexkit/protocols/dao.py

@@ -21,6 +21,7 @@ with the database.
 # ruff: noqa: PLR0913
 
 import typing
+import warnings
 from abc import ABC, abstractmethod
 from collections.abc import AsyncGenerator, AsyncIterator, Collection, Mapping
 from contextlib import AbstractAsyncContextManager
@@ -29,6 +30,7 @@ from typing import Any, Optional, TypeVar, Union, overload
 from uuid import uuid4
 
 from pydantic import BaseModel
+from typing_extensions import deprecated
 
 from hexkit.utils import FieldNotInModelError, validate_fields_in_model
 
@@ -259,6 +261,9 @@ class DaoNaturalId(DaoCommons[Dto], typing.Protocol[Dto]):
         ...
 
 
+@deprecated(
+    "uuid4_id_generator is deprecated as of v3.6 and will be removed in hexkit v4."
+)
 async def uuid4_id_generator() -> AsyncGenerator[str, None]:
     """Generates a new ID using the UUID4 algorithm.
     This is an AsyncGenerator to be compliant with the id_generator requirements of the
@@ -441,6 +446,15 @@ class DaoFactoryProtocol(DaoFactoryBase, ABC):
             # instantiate the default ID generator:
             id_generator = uuid4_id_generator()
 
+        if dto_creation_model is not None:
+            dep_msg = (
+                "The DAO API (and existing providers) are deprecated as of v3.6."
+                + " They will be simplified in hexkit v4."
+                + " Please plan to provide IDs during resource creation. The same model"
+                + " should be used for both creation and retrieval."
+            )
+            warnings.warn(dep_msg, category=DeprecationWarning, stacklevel=2)
+
         return await self._get_dao(
             name=name,
             dto_model=dto_model,

{hexkit-3.5.0 → hexkit-3.7.0}/src/hexkit/protocols/objstorage.py

@@ -122,6 +122,7 @@ class ObjectStorageProtocol(ABC):
         object_id: str,
         part_number: int,
         expires_after: int = 3600,
+        part_md5: Optional[str] = None,
     ) -> str:
         """Given a id of an instantiated multipart upload along with the corresponding
         bucket and object ID, it returns a presigned URL for uploading a file part with the
@@ -137,6 +138,7 @@ class ObjectStorageProtocol(ABC):
             object_id=object_id,
             part_number=part_number,
             expires_after=expires_after,
+            part_md5=part_md5,
         )
 
     async def abort_multipart_upload(
@@ -207,6 +209,12 @@ class ObjectStorageProtocol(ABC):
             bucket_id=bucket_id, object_id=object_id, object_md5sum=object_md5sum
         )
 
+    async def get_object_etag(self, *, bucket_id: str, object_id: str) -> str:
+        """Returns the etag of an object."""
+        self._validate_bucket_id(bucket_id)
+        self._validate_object_id(object_id)
+        return await self._get_object_etag(bucket_id=bucket_id, object_id=object_id)
+
     async def get_object_size(self, *, bucket_id: str, object_id: str) -> int:
         """Returns the size of an object in bytes."""
         self._validate_bucket_id(bucket_id)
@@ -220,9 +228,15 @@ class ObjectStorageProtocol(ABC):
         source_object_id: str,
         dest_bucket_id: str,
         dest_object_id: str,
+        abort_failed: bool = True,
     ) -> None:
         """Copy an object from one bucket (`source_bucket_id` and `source_object_id`) to
         another bucket (`dest_bucket_id` and `dest_object_id`).
+
+        If `abort_failed` is set to true (default), a failed copy operation tries to
+        abort the ongoing multipart upload it created (if using multipart mode).
+        This only works reliably as long as there are no other ongoing multipart operations for
+        the same destination bucket and object ID, in which case this should be set to false.
         """
         self._validate_bucket_id(source_bucket_id)
         self._validate_object_id(source_object_id)
@@ -233,6 +247,7 @@ class ObjectStorageProtocol(ABC):
             source_object_id=source_object_id,
             dest_bucket_id=dest_bucket_id,
             dest_object_id=dest_object_id,
+            abort_failed=abort_failed,
         )
 
     async def delete_object(self, *, bucket_id: str, object_id: str) -> None:
@@ -336,6 +351,7 @@ class ObjectStorageProtocol(ABC):
         object_id: str,
         part_number: int,
         expires_after: int = 3600,
+        part_md5: Optional[str] = None,
     ) -> str:
         """
         Given a id of an instantiated multipart upload along with the corresponding
@@ -402,6 +418,15 @@ class ObjectStorageProtocol(ABC):
         """
         ...
 
+    @abstractmethod
+    async def _get_object_etag(self, *, bucket_id: str, object_id: str) -> str:
+        """Return the etag of an object.
+
+        *To be implemented by the provider. Input validation is done outside of this
+        method.*
+        """
+        ...
+
     @abstractmethod
     async def _get_object_size(self, *, bucket_id: str, object_id: str) -> int:
         """
@@ -435,11 +460,17 @@ class ObjectStorageProtocol(ABC):
         source_object_id: str,
         dest_bucket_id: str,
         dest_object_id: str,
+        abort_failed: bool = True,
     ) -> None:
         """
         Copy an object from one bucket (`source_bucket_id` and `source_object_id`) to
         another bucket (`dest_bucket_id` and `dest_object_id`).
 
+        If `abort_failed` is set to true (default), a failed copy operation tries to
+        abort the ongoing multipart upload it created (if using multipart mode).
+        This only works reliably as long as there are no other ongoing multipart operations for
+        the same destination bucket and object ID, in which case this should be set to false.
+
         *To be implemented by the provider. Input validation is done outside of this
         method.*
         """

{hexkit-3.5.0 → hexkit-3.7.0}/src/hexkit/providers/akafka/testcontainer.py

@@ -151,7 +151,7 @@ class KafkaSSLContainer(DockerContainer):
             with tarfile.TarFile(fileobj=archive, mode="w") as tar:
                 tarinfo = tarfile.TarInfo(name=path)
                 tarinfo.size = len(content)
-                tarinfo.mtime = time.time()  # type: ignore
+                tarinfo.mtime = time.time()
                 tar.addfile(tarinfo, BytesIO(content))
             archive.seek(0)
             self.get_wrapped_container().put_archive("/", archive)

{hexkit-3.5.0 → hexkit-3.7.0}/src/hexkit/providers/mongodb/provider.py

@@ -22,6 +22,7 @@ Utilities for testing are located in `./testutils.py`.
 # ruff: noqa: PLR0913
 
 import json
+import warnings
 from abc import ABC
 from collections.abc import AsyncGenerator, AsyncIterator, Collection, Mapping
 from contextlib import AbstractAsyncContextManager
@@ -163,6 +164,17 @@ class MongoDbDaoBase(ABC, Generic[Dto]):
         self._document_to_dto = document_to_dto
         self._dto_to_document = dto_to_document
 
+        warnings.warn(
+            "The MongoDbDaoBase class and subclasses are deprecated as of v3.6 and will"
+            + " be replaced in hexkit v4 with the new MongoDbDao class. To replace the"
+            + " MongoDbDaoNaturalId: just use the new class. To replace the"
+            + " MongoDbDaoSurrogateId: use the new class, remove the creation model and"
+            + " id_generator parameters, and make sure the supplied DTO model includes"
+            + " the ID field with a default factory for generating new IDs.",
+            category=DeprecationWarning,
+            stacklevel=2,
+        )
+
     async def get_by_id(self, id_: str) -> Dto:
         """Get a resource by providing its ID.
 

{hexkit-3.5.0 → hexkit-3.7.0}/src/hexkit/providers/mongokafka/provider.py

@@ -255,7 +255,14 @@ class MongoKafkaDaoPublisher(Generic[Dto]):
         document = self._dao._dto_to_document(dto)
         document.setdefault("__metadata__", {})["correlation_id"] = correlation_id
         result = await self._collection.replace_one(
-            {"_id": document["_id"], "__metadata__.deleted": False}, document
+            {
+                "_id": document["_id"],
+                "$or": [
+                    {"__metadata__": {"$exists": False}},
+                    {"__metadata__.deleted": False},
+                ],
+            },
+            document,
         )
         if result.matched_count == 0:
             raise ResourceNotFoundError(id_=document["_id"])
@@ -282,7 +289,14 @@ class MongoKafkaDaoPublisher(Generic[Dto]):
             },
         }
         result = await self._collection.replace_one(
-            {"_id": document["_id"], "__metadata__.deleted": False}, document
+            {
+                "_id": document["_id"],
+                "$or": [
+                    {"__metadata__": {"$exists": False}},
+                    {"__metadata__.deleted": False},
+                ],
+            },
+            document,
         )
         if result.matched_count == 0:
             raise ResourceNotFoundError(id_=id_)

{hexkit-3.5.0 → hexkit-3.7.0}/src/hexkit/providers/s3/provider.py

@@ -223,27 +223,33 @@ class S3ObjectStorage(ObjectStorageProtocol):
 
     async def _does_bucket_exist(self, bucket_id: str) -> bool:
         """Check whether a bucket with the specified ID (`bucket_id`) exists.
-        Return `True` if it exists and `False` otherwise.
+
+        Returns `True` if it exists and `False` otherwise.
+
+        Note that this method does not need to have the permission to list buckets.
         """
         try:
-            bucket_list = await asyncio.to_thread(self._client.list_buckets)
+            await asyncio.to_thread(self._client.head_bucket, Bucket=bucket_id)
         except botocore.exceptions.ClientError as error:
+            if error.response["Error"]["Code"] == "404":
+                return False
             raise self._translate_s3_client_errors(
                 error, bucket_id=bucket_id
             ) from error
-
-        return any(bucket["Name"] == bucket_id for bucket in bucket_list["Buckets"])
+        return True
 
     async def _assert_bucket_exists(self, bucket_id: str) -> None:
-        """Checks if the bucket with specified ID (`bucket_id`) exists and throws an
-        BucketNotFoundError otherwise.
+        """Assert that the bucket with the specified ID (`bucket_id`) exists.
+
+        If it does not exist, a BucketNotFoundError is raised.
         """
         if not await self.does_bucket_exist(bucket_id):
             raise self.BucketNotFoundError(bucket_id=bucket_id)
 
     async def _assert_bucket_not_exists(self, bucket_id: str) -> None:
-        """Checks if the bucket with specified ID (`bucket_id`) exists. If so, it throws
-        an BucketAlreadyExistsError.
+        """Assert that the bucket with the specified ID (`bucket_id`) does not exist.
+
+        If it exists, a BucketAlreadyExistsError is raised.
         """
         if await self.does_bucket_exist(bucket_id):
             raise self.BucketAlreadyExistsError(bucket_id=bucket_id)
@@ -274,7 +280,7 @@ class S3ObjectStorage(ObjectStorageProtocol):
         await self._assert_bucket_exists(bucket_id)
 
         try:
-            bucket = self._resource.Bucket(bucket_id)
+            bucket = self._resource.Bucket(bucket_id)  # pyright: ignore
             content = await asyncio.to_thread(bucket.objects.all)
             if delete_content:
                 await asyncio.to_thread(content.delete)
@@ -289,7 +295,7 @@ class S3ObjectStorage(ObjectStorageProtocol):
         await self._assert_bucket_exists(bucket_id)
 
         try:
-            bucket = self._resource.Bucket(bucket_id)
+            bucket = self._resource.Bucket(bucket_id)  # pyright: ignore
             content = await asyncio.to_thread(bucket.objects.all)
             return [object_summary.key for object_summary in content]
         except botocore.exceptions.ClientError as error:
@@ -306,17 +312,18 @@ class S3ObjectStorage(ObjectStorageProtocol):
         Return `True` if checks succeed and `False` otherwise.
         """
         if object_md5sum is not None:
-            raise NotImplementedError("Md5 checking is not yet implemented.")
+            raise NotImplementedError("MD5 checking is not yet implemented.")
 
         try:
-            _ = await asyncio.to_thread(
-                self._client.head_object,
-                Bucket=bucket_id,
-                Key=object_id,
+            await asyncio.to_thread(
+                self._client.head_object, Bucket=bucket_id, Key=object_id
             )
-        except botocore.exceptions.ClientError:
-            return False
-
+        except botocore.exceptions.ClientError as error:
+            if error.response["Error"]["Code"] == "404":
+                return False
+            raise self._translate_s3_client_errors(
+                error, bucket_id=bucket_id, object_id=object_id
+            ) from error
         return True
 
     async def _assert_object_exists(self, *, bucket_id: str, object_id: str) -> None:
@@ -451,7 +458,7 @@ class S3ObjectStorage(ObjectStorageProtocol):
             )
 
     async def _init_multipart_upload(self, *, bucket_id: str, object_id: str) -> str:
-        """Initiates a mulipart upload procedure. Returns the upload ID."""
+        """Initiates a multipart upload procedure. Returns the upload ID."""
         await self._assert_no_multipart_upload(bucket_id=bucket_id, object_id=object_id)
 
         try:
@@ -473,6 +480,7 @@ class S3ObjectStorage(ObjectStorageProtocol):
         object_id: str,
         part_number: int,
         expires_after: int = 3600,
+        part_md5: Optional[str] = None,
     ) -> str:
         """Given a id of an instantiated multipart upload along with the corresponding
         bucket and object ID, it returns a presigned URL for uploading a file part with the
@@ -491,16 +499,20 @@ class S3ObjectStorage(ObjectStorageProtocol):
             upload_id=upload_id, bucket_id=bucket_id, object_id=object_id
         )
 
+        params = {
+            "Bucket": bucket_id,
+            "Key": object_id,
+            "UploadId": upload_id,
+            "PartNumber": part_number,
+        }
+        # add additional parameters if any were passed
+        if part_md5:
+            params["ContentMD5"] = part_md5
         try:
             return await asyncio.to_thread(
                 self._client.generate_presigned_url,
                 ClientMethod="upload_part",
-                Params={
-                    "Bucket": bucket_id,
-                    "Key": object_id,
-                    "UploadId": upload_id,
-                    "PartNumber": part_number,
-                },
+                Params=params,
                 ExpiresIn=expires_after,
             )
         except botocore.exceptions.ClientError as error:
@@ -757,6 +769,22 @@ class S3ObjectStorage(ObjectStorageProtocol):
 
         return presigned_url
 
+    async def _get_object_etag(self, *, bucket_id: str, object_id: str) -> str:
+        """Return the etag of an object."""
+        await self._assert_object_exists(bucket_id=bucket_id, object_id=object_id)
+
+        object_metadata = await self._get_object_metadata(
+            bucket_id=bucket_id, object_id=object_id
+        )
+
+        if "ETag" not in object_metadata:
+            raise self.ObjectError(
+                f"Could not get the etag of the object with ID '{object_id}' in"
+                + f" bucket '{bucket_id}'."
+            )
+
+        return object_metadata["ETag"]
+
     async def _get_object_size(self, *, bucket_id: str, object_id: str) -> int:
         """Returns the size of an object in bytes."""
         await self._assert_object_exists(bucket_id=bucket_id, object_id=object_id)
@@ -795,9 +823,15 @@ class S3ObjectStorage(ObjectStorageProtocol):
         source_object_id: str,
         dest_bucket_id: str,
         dest_object_id: str,
+        abort_failed: bool = True,
     ) -> None:
         """Copy an object from one bucket (`source_bucket_id` and `source_object_id`) to
         another bucket (`dest_bucket_id` and `dest_object_id`).
+
+        If `abort_failed` is set to true (default), a failed copy operation tries to
+        abort the ongoing multipart upload it created (if using multipart mode).
+        This only works reliably as long as there are no other ongoing multipart operations for
+        the same destination bucket and object ID, in which case this should be set to false.
         """
         file_size = await self._get_object_size(
             bucket_id=source_bucket_id, object_id=source_object_id
@@ -825,6 +859,22 @@ class S3ObjectStorage(ObjectStorageProtocol):
                 Config=transfer_config,
             )
         except botocore.exceptions.ClientError as error:
+            if abort_failed:
+                # try to find and abort the multipart operation, if multipart copy mode is used
+                # 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(
+                        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],
+                            bucket_id=dest_bucket_id,
+                            object_id=dest_object_id,
+                        )
+                except botocore.exceptions.ClientError:
+                    pass
             raise self._translate_s3_client_errors(error) from error
 
     async def _delete_object(self, *, bucket_id: str, object_id: str) -> None:

{hexkit-3.5.0 → hexkit-3.7.0}/src/hexkit/providers/s3/testutils/__init__.py

@@ -20,18 +20,27 @@ from ._fixtures import (
     MEBIBYTE,
     TEST_FILE_DIR,
     TEST_FILE_PATHS,
+    FederatedS3Fixture,
     FileObject,
     S3ContainerFixture,
     S3Fixture,
+    S3MultiContainerFixture,
     calc_md5,
+    clean_federated_s3_fixture,
     clean_s3_fixture,
+    federated_s3_fixture,
+    get_clean_federated_s3_fixture,
     get_clean_s3_fixture,
+    get_persistent_federated_s3_fixture,
     get_persistent_s3_fixture,
     get_s3_container_fixture,
+    get_s3_multi_container_fixture,
+    persistent_federated_s3_fixture,
     persistent_s3_fixture,
     populate_storage,
     s3_container_fixture,
     s3_fixture,
+    s3_multi_container_fixture,
     temp_file_object,
     tmp_file,
     upload_file,
@@ -73,4 +82,13 @@ __all__ = [
     "upload_part",
     "upload_part_of_size",
     "upload_part_via_url",
+    "FederatedS3Fixture",
+    "S3MultiContainerFixture",
+    "clean_federated_s3_fixture",
+    "federated_s3_fixture",
+    "get_clean_federated_s3_fixture",
+    "get_s3_multi_container_fixture",
+    "get_persistent_federated_s3_fixture",
+    "s3_multi_container_fixture",
+    "persistent_federated_s3_fixture",
 ]

{hexkit-3.5.0 → hexkit-3.7.0}/src/hexkit/providers/s3/testutils/_fixtures.py

@@ -24,7 +24,7 @@ from collections.abc import AsyncGenerator, Generator
 from contextlib import contextmanager
 from pathlib import Path
 from tempfile import NamedTemporaryFile
-from typing import Any, NamedTuple, Optional, Union
+from typing import NamedTuple, Optional, Union
 
 try:
     from typing import Self
@@ -64,7 +64,7 @@ __all__ = [
 ]
 
 
-LOCALSTACK_IMAGE = "localstack/localstack:3.5.0"
+LOCALSTACK_IMAGE = "localstack/localstack:3.8.1"
 
 TEST_FILE_DIR = Path(__file__).parent.parent.resolve() / "test_files"
 
@@ -223,19 +223,23 @@ class S3ContainerFixture(LocalStackContainer):
 
     def __init__(
         self,
-        port: int = 4566,
+        image: str = LOCALSTACK_IMAGE,
+        edge_port: int = 4566,
         region_name: Optional[str] = None,
-        **kwargs: Any,
+        **kwargs,
     ) -> None:
         """Initialize the container."""
-        super().__init__(image=LOCALSTACK_IMAGE)
+        super().__init__(
+            image=image, edge_port=edge_port, region_name=region_name, **kwargs
+        )
 
     def __enter__(self) -> Self:
         """Enter the container context."""
         super().__enter__()
-        s3_endpoint_url = self.get_url()
+        url = self.get_url()
+        url = url.replace("localhost", "127.0.0.1")
         s3_config = S3Config(  # type: ignore [call-arg]
-            s3_endpoint_url=s3_endpoint_url,
+            s3_endpoint_url=url,
             s3_access_key_id="test",
             s3_secret_access_key=SecretStr("test"),
         )
@@ -344,3 +348,148 @@ def tmp_file() -> Generator[FileObject, None, None]:
     """A fixture that provides a temporary file."""
     with temp_file_object() as temp_file:
         yield temp_file
+
+
+class FederatedS3Fixture:
+    """Fixture containing multiple S3 fixtures to simulate federated storage."""
+
+    def __init__(self, storages: dict[str, S3Fixture]):
+        self.storages = storages
+
+    def get_configs_by_alias(self) -> dict[str, S3Config]:
+        """Get the S3Config instance for each object storage in the fixture."""
+        return {alias: self.storages[alias].config for alias in self.storages}
+
+    async def populate_dummy_items(self, alias: str, contents: dict[str, list[str]]):
+        """Convenience function to populate a specific S3Fixture.
+
+        Args:
+        - `alias`: The alias of the S3Fixture to populate.
+        - `contents`: A dictionary with bucket names as keys and lists of object names
+        as values. The buckets can be empty, and the objects are created with a size of
+        1 byte.
+        """
+        if alias not in self.storages:
+            # This would indicate some kind of mismatch between config and fixture
+            raise RuntimeError(f"Alias '{alias}' not found in the federated S3 fixture")
+        storage = self.storages[alias]
+
+        # Populate the buckets so even empty buckets are established
+        await storage.populate_buckets([bucket for bucket in contents])
+
+        # Add the dummy items
+        for bucket, objects in contents.items():
+            for obj in objects:
+                with temp_file_object(bucket, obj, 1) as file:
+                    await storage.populate_file_objects([file])
+
+
+class S3MultiContainerFixture:
+    """Fixture for managing multiple running S3 test containers in order to mimic
+    multiple object storages.
+
+    Without this fixture, separate S3Fixture instances would access the same
+    underlying storage resources.
+    """
+
+    def __init__(self, s3_containers: dict[str, S3ContainerFixture]):
+        self.s3_containers = s3_containers
+
+    def __enter__(self):
+        """Enter the context manager and start the S3 containers."""
+        for container in self.s3_containers.values():
+            container.__enter__()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Exit the context manager and clean up the S3 containers."""
+        for container in self.s3_containers.values():
+            container.__exit__(exc_type, exc_val, exc_tb)
+
+
+def _s3_multi_container_fixture(
+    request,
+) -> Generator[S3MultiContainerFixture, None, None]:
+    """Fixture function for getting multiple running S3 test containers."""
+    try:
+        storage_aliases = request.getfixturevalue("storage_aliases")
+    except pytest.FixtureLookupError as err:
+        raise NotImplementedError(
+            "You must provide a 'storage_aliases' fixture in your test setup."
+            + " It must have the same scope as 's3_multi_container'"
+            + " and it must return a list of the storage aliases to be used."
+        ) from err
+
+    if not storage_aliases:
+        raise RuntimeError("The 'storage_aliases' list must not be empty.")
+    s3_containers = {alias: S3ContainerFixture() for alias in storage_aliases}
+    with S3MultiContainerFixture(s3_containers) as s3_multi_container:
+        yield s3_multi_container
+
+
+def get_s3_multi_container_fixture(
+    scope: PytestScope = "session", name: str = "s3_multi_container"
+):
+    """Get a fixture containing multiple LocalStack test containers.
+
+    By default, the session scope is used for LocalStack test containers.
+    Requires that a 'storage_aliases' fixture is provided in the test setup.
+    """
+    return pytest.fixture(_s3_multi_container_fixture, scope=scope, name=name)
+
+
+s3_multi_container_fixture = get_s3_multi_container_fixture()
+
+
+def _persistent_federated_s3_fixture(
+    s3_multi_container: S3MultiContainerFixture,
+) -> Generator[FederatedS3Fixture, None, None]:
+    """Fixture function that creates a persistent FederatedS3Fixture.
+
+    The state of each S3 storage in the fixture is not cleaned up.
+    """
+    s3_fixtures = {}
+    for alias, container in s3_multi_container.s3_containers.items():
+        config = container.s3_config
+        storage = S3ObjectStorage(config=config)
+        s3_fixtures[alias] = S3Fixture(config=config, storage=storage)
+    yield FederatedS3Fixture(s3_fixtures)
+
+
+def get_persistent_federated_s3_fixture(
+    scope: PytestScope = "function", name: str = "federated_s3"
+):
+    """Get a federated S3 storage fixture with desired scope.
+
+    The state of the S3 storage is not cleaned up by the fixture.
+    """
+    return pytest.fixture(_persistent_federated_s3_fixture, scope=scope, name=name)
+
+
+persistent_federated_s3_fixture = get_persistent_federated_s3_fixture()
+
+
+async def _clean_federated_s3_fixture(
+    s3_multi_container: S3MultiContainerFixture,
+) -> AsyncGenerator[FederatedS3Fixture, None]:
+    """Fixture function that creates a clean FederatedS3Fixture instance.
+
+    The state of each S3 storage is cleaned up before yielding the fixture.
+    """
+    for federated_s3_fixture in _persistent_federated_s3_fixture(s3_multi_container):
+        for s3_fixture in federated_s3_fixture.storages.values():
+            await s3_fixture.delete_buckets()
+        yield federated_s3_fixture
+
+
+def get_clean_federated_s3_fixture(
+    scope: PytestScope = "function", name: str = "federated_s3"
+):
+    """Get a federated S3 storage fixture with desired scope.
+
+    The state of the S3 storage is not cleaned up by the fixture.
+    """
+    return pytest_asyncio.fixture(_clean_federated_s3_fixture, scope=scope, name=name)
+
+
+federated_s3_fixture = clean_federated_s3_fixture = get_clean_federated_s3_fixture()

{hexkit-3.5.0 → hexkit-3.7.0}/src/hexkit/providers/s3/testutils/_utils.py

@@ -44,7 +44,7 @@ class FileObject(BaseModel):
     bucket_id: str
     object_id: str
 
-    @computed_field  # type: ignore [misc]
+    @computed_field  # type: ignore [prop-decorator]
     @property
     def content(self) -> bytes:
         """Extract the content from the file at the provided path"""
@@ -53,7 +53,7 @@ class FileObject(BaseModel):
         with open(self.file_path, "rb") as file:
             return file.read()
 
-    @computed_field  # type: ignore [misc]
+    @computed_field  # type: ignore [prop-decorator]
     @property
     def md5(self) -> str:
         """Calculate the md5 hash of the content"""

{hexkit-3.5.0 → hexkit-3.7.0/src/hexkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hexkit
-Version: 3.5.0
+Version: 3.7.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