hexkit 0.11.1__tar.gz → 1.1.0__tar.gz

hexkit-1.1.0/MANIFEST.in

@@ -0,0 +1 @@
+include src/hexkit/providers/s3/test_files/*.yaml

{hexkit-0.11.1/src/hexkit.egg-info → hexkit-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hexkit
-Version: 0.11.1
+Version: 1.1.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
@@ -31,13 +31,13 @@ Provides-Extra: mongodb
 Requires-Dist: motor<4,>=3.1.1; extra == "mongodb"
 Provides-Extra: test-akafka
 Requires-Dist: hexkit[akafka]; extra == "test-akafka"
-Requires-Dist: testcontainers[kafka]<4,>=3.4.1; extra == "test-akafka"
+Requires-Dist: testcontainers[kafka]<4,>=3.7.1; extra == "test-akafka"
 Provides-Extra: test-s3
 Requires-Dist: hexkit[s3]; extra == "test-s3"
-Requires-Dist: testcontainers<4,>=3.4.1; extra == "test-s3"
+Requires-Dist: testcontainers<4,>=3.7.1; extra == "test-s3"
 Provides-Extra: test-mongodb
 Requires-Dist: hexkit[mongodb]; extra == "test-mongodb"
-Requires-Dist: testcontainers[mongo]<4,>=3.4.1; extra == "test-mongodb"
+Requires-Dist: testcontainers[mongo]<4,>=3.7.1; extra == "test-mongodb"
 Provides-Extra: test
 Requires-Dist: hexkit[test-akafka,test-mongodb,test-s3]; extra == "test"
 Provides-Extra: all

{hexkit-0.11.1 → hexkit-1.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hexkit"
-version = "0.11.1"
+version = "1.1.0"
 description = "A Toolkit for Building Microservices using the Hexagonal Architecture"
 readme = "README.md"
 authors = [
@@ -35,9 +35,9 @@ akafka = ["aiokafka~=0.8.0", "jsonschema >=4.17.3, <5"]
 s3 = ["boto3 >=1.26.50, <2", "botocore >=1.29.50, <2"]
 mongodb = ["motor >=3.1.1, <4"]
 
-test-akafka = ["hexkit[akafka]", "testcontainers[kafka] >=3.4.1, <4"]
-test-s3 = ["hexkit[s3]", "testcontainers >=3.4.1, <4"]
-test-mongodb = ["hexkit[mongodb]", "testcontainers[mongo] >=3.4.1, <4"]
+test-akafka = ["hexkit[akafka]", "testcontainers[kafka] >=3.7.1, <4"]
+test-s3 = ["hexkit[s3]", "testcontainers >=3.7.1, <4"]
+test-mongodb = ["hexkit[mongodb]", "testcontainers[mongo] >=3.7.1, <4"]
 test = ["hexkit[test-akafka,test-s3,test-mongodb]"]
 
 all = ["hexkit[test]"]
@@ -47,6 +47,3 @@ Repository = "https://github.com/ghga-de/hexkit"
 
 [tool.setuptools.packages.find]
 where = ["src"]
-
-[tool.setuptools.package-data]
-"hexkit.providers.s3.test_files" = ["*.yaml"]

hexkit-1.1.0/src/hexkit/correlation.py

@@ -0,0 +1,97 @@
+# Copyright 2021 - 2023 Universität Tübingen, DKFZ, EMBL, and Universität zu Köln
+# for the German Human Genome-Phenome Archive (GHGA)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""Utilities related to correlation IDs"""
+
+import logging
+from contextlib import asynccontextmanager
+from contextvars import ContextVar
+from uuid import UUID, uuid4
+
+from hexkit.utils import set_context_var
+
+log = logging.getLogger()
+
+correlation_id_var: ContextVar[str] = ContextVar("correlation_id", default="")
+
+__all__ = [
+    "set_correlation_id",
+    "get_correlation_id",
+    "new_correlation_id",
+    "validate_correlation_id",
+    "CorrelationIdContextError",
+    "InvalidCorrelationIdError",
+]
+
+
+class CorrelationIdContextError(RuntimeError):
+    """Raised when the correlation ID ContextVar is unexpectedly not set."""
+
+
+class InvalidCorrelationIdError(RuntimeError):
+    """Raised when a correlation ID fails validation."""
+
+    def __init__(self, *, correlation_id: str):
+        message = f"Invalid correlation ID found: '{correlation_id}'"
+        super().__init__(message)
+
+
+def new_correlation_id() -> str:
+    """Generates a new correlation ID."""
+    return str(uuid4())
+
+
+def validate_correlation_id(correlation_id: str):
+    """Raises an error if the correlation ID is invalid.
+
+    Raises:
+        InvalidCorrelationIdError: If the correlation ID is empty or invalid.
+    """
+    try:
+        UUID(correlation_id)
+    except ValueError as err:
+        raise InvalidCorrelationIdError(correlation_id=correlation_id) from err
+
+
+@asynccontextmanager
+async def set_correlation_id(correlation_id: str):
+    """Set the correlation ID for the life of the context.
+
+    Raises:
+        InvalidCorrelationIdError: when the correlation ID is empty or invalid.
+    """
+    validate_correlation_id(correlation_id)
+
+    async with set_context_var(correlation_id_var, correlation_id):
+        log.info("Set context correlation ID to %s", correlation_id)
+        yield
+
+
+def get_correlation_id() -> str:
+    """Get the correlation ID.
+
+    This should only be called when the correlation ID ContextVar is expected to be set.
+
+    Raises:
+        CorrelationIdContextError: when the correlation ID ContextVar is not set.
+        InvalidCorrelationIdError: when the correlation ID is invalid.
+    """
+    if not (correlation_id := correlation_id_var.get()):
+        raise CorrelationIdContextError()
+
+    validate_correlation_id(correlation_id)
+
+    return correlation_id

{hexkit-0.11.1 → hexkit-1.1.0}/src/hexkit/inject.py

@@ -46,8 +46,6 @@ __all__ = [
     "Configurator",
 ]
 
-# pylint: disable=c-extension-no-member
-
 
 class NotConstructableError(TypeError):
     """Thrown when an AsyncContextConstructable was expected but not obtained."""
@@ -108,9 +106,6 @@ class AsyncConstructor(dependency_injector.providers.Resource):
 
         return resource
 
-    # This pylint error is inherited from the dependency_injector framework, other
-    # DI providers use the same basic signature:
-    # pylint: disable=keyword-arg-before-vararg
     def __init__(
         self,
         provides: Optional[

{hexkit-0.11.1 → hexkit-1.1.0}/src/hexkit/protocols/dao.py

@@ -450,7 +450,7 @@ class DaoFactoryProtocol(ABC):
 
     @overload
     @abstractmethod
-    async def _get_dao(  # pylint: disable=arguments-differ
+    async def _get_dao(
         self,
         *,
         name: str,

{hexkit-0.11.1 → hexkit-1.1.0}/src/hexkit/protocols/objstorage.py

@@ -155,7 +155,6 @@ class ObjectStorageProtocol(ABC):
             upload_id=upload_id, bucket_id=bucket_id, object_id=object_id
         )
 
-    # pylint: disable=too-many-arguments
     async def complete_multipart_upload(
         self,
         *,
@@ -367,7 +366,6 @@ class ObjectStorageProtocol(ABC):
         """
         ...
 
-    # pylint: disable=too-many-arguments
     @abstractmethod
     async def _complete_multipart_upload(
         self,

{hexkit-0.11.1 → hexkit-1.1.0}/src/hexkit/providers/akafka/provider.py

@@ -23,10 +23,12 @@ Require dependencies of the `akafka` extra. See the `setup.cfg`.
 
 import json
 import logging
+import ssl
 from contextlib import asynccontextmanager
-from typing import Any, Callable, Protocol, TypeVar
+from typing import Any, Callable, Literal, Optional, Protocol, TypeVar
 
 from aiokafka import AIOKafkaConsumer, AIOKafkaProducer
+from aiokafka.helpers import create_ssl_context
 from pydantic import Field
 from pydantic_settings import BaseSettings
 
@@ -35,11 +37,6 @@ from hexkit.custom_types import Ascii, JsonObject
 from hexkit.protocols.eventpub import EventPublisherProtocol
 from hexkit.protocols.eventsub import EventSubscriberProtocol
 
-try:  # workaround for https://github.com/pydantic/pydantic/issues/5821
-    from typing_extensions import Literal
-except ImportError:
-    from typing import Literal  # type: ignore
-
 __all__ = [
     "KafkaConfig",
     "KafkaEventPublisher",
@@ -70,6 +67,29 @@ class KafkaConfig(BaseSettings):
         examples=[["localhost:9092"]],
         description="A list of connection strings to connect to Kafka bootstrap servers.",
     )
+    kafka_security_protocol: Literal["PLAINTEXT", "SSL"] = Field(
+        "PLAINTEXT",
+        description="Protocol used to communicate with brokers. "
+        + "Valid values are: PLAINTEXT, SSL.",
+    )
+    kafka_ssl_cafile: str = Field(
+        "",
+        description="Certificate Authority file path containing certificates"
+        + " used to sign broker certificates. If a CA not specified, the default"
+        + " system CA will be used if found by OpenSSL.",
+    )
+    kafka_ssl_certfile: str = Field(
+        "",
+        description="Optional filename of client certificate, as well as any"
+        + " CA certificates needed to establish the certificate's authenticity.",
+    )
+    kafka_ssl_keyfile: str = Field(
+        "", description="Optional filename containing the client private key."
+    )
+    kafka_ssl_password: str = Field(
+        "",
+        description="Optional password to be used for the client private key.",
+    )
 
 
 class EventTypeNotFoundError(RuntimeError):
@@ -84,13 +104,29 @@ def generate_client_id(*, service_name: str, instance_id: str) -> str:
     return f"{service_name}.{instance_id}"
 
 
+def generate_ssl_context(config: KafkaConfig) -> Optional[ssl.SSLContext]:
+    """Generate SSL context for an encrypted SSL connection to Kafka broker."""
+    return (
+        create_ssl_context(
+            cafile=config.kafka_ssl_cafile,
+            certfile=config.kafka_ssl_certfile,
+            keyfile=config.kafka_ssl_keyfile,
+            password=config.kafka_ssl_password,
+        )
+        if config.kafka_security_protocol == "SSL"
+        else None
+    )
+
+
 class KafkaProducerCompatible(Protocol):
     """A python duck type protocol describing an AIOKafkaProducer or equivalent."""
 
-    def __init__(
+    def __init__(  # noqa: PLR0913
         self,
         *,
         bootstrap_servers: str,
+        security_protocol: str,
+        ssl_context: Optional[ssl.SSLContext],
         client_id: str,
         key_serializer: Callable[[Any], bytes],
         value_serializer: Callable[[Any], bytes],
@@ -149,6 +185,8 @@ class KafkaEventPublisher(EventPublisherProtocol):
 
         producer = kafka_producer_cls(
             bootstrap_servers=",".join(config.kafka_servers),
+            security_protocol=config.kafka_security_protocol,
+            ssl_context=generate_ssl_context(config),
             client_id=client_id,
             key_serializer=lambda key: key.encode("ascii"),
             value_serializer=lambda event_value: json.dumps(event_value).encode(
@@ -220,6 +258,8 @@ class KafkaConsumerCompatible(Protocol):
         self,
         *topics: Ascii,
         bootstrap_servers: str,
+        security_protocol: str,
+        ssl_context: Optional[ssl.SSLContext],
         client_id: str,
         group_id: str,
         auto_offset_reset: Literal["earliest"],
@@ -297,6 +337,8 @@ class KafkaEventSubscriber(InboundProviderBase):
         consumer = kafka_consumer_cls(
             *topics,
             bootstrap_servers=",".join(config.kafka_servers),
+            security_protocol=config.kafka_security_protocol,
+            ssl_context=generate_ssl_context(config),
             client_id=client_id,
             group_id=config.service_name,
             auto_offset_reset="earliest",
@@ -311,8 +353,6 @@ class KafkaEventSubscriber(InboundProviderBase):
         finally:
             await consumer.stop()
 
-    # pylint: disable=too-many-arguments
-    # (some arguments are only used for testing)
     def __init__(
         self, *, consumer: KafkaConsumerCompatible, translator: EventSubscriberProtocol
     ):

hexkit-1.1.0/src/hexkit/providers/akafka/testcontainer.py

@@ -0,0 +1,177 @@
+# Copyright 2021 - 2023 Universität Tübingen, DKFZ, EMBL, and Universität zu Köln
+# for the German Human Genome-Phenome Archive (GHGA)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""Improved Kafka test containers."""
+
+import tarfile
+import time
+from io import BytesIO
+from ssl import SSLError
+from textwrap import dedent
+from typing import Literal, Optional
+
+from kafka import KafkaConsumer
+from kafka.errors import KafkaError, NoBrokersAvailable, UnrecognizedBrokerVersion
+from testcontainers.core.container import DockerContainer
+from testcontainers.core.waiting_utils import wait_container_is_ready
+
+__all__ = ["KafkaSSLContainer"]
+
+DEFAULT_IMAGE = "confluentinc/cp-kafka:7.5.1"
+
+DEFAULT_PORT = 9093  # default port for the Kafka container
+BROKER_PORT = 9092  # auxiliary port for inter broker listener
+
+
+class KafkaSSLContainer(DockerContainer):
+    """Kafka container that supports SSL (or actually TLS)."""
+
+    TC_START_SCRIPT = "/tc-start.sh"
+    SECRETS_PATH = "/etc/kafka/secrets"
+
+    def __init__(  # noqa: C901, PLR0912, PLR0913
+        self,
+        image: str = DEFAULT_IMAGE,
+        port: int = DEFAULT_PORT,
+        cert: Optional[str] = None,
+        key: Optional[str] = None,
+        trusted: Optional[str] = None,
+        password: Optional[str] = None,
+        client_auth: Optional[Literal["requested", "required", "none"]] = None,
+        **kwargs,
+    ) -> None:
+        """Initialize the Kafka SSL container with the given parameters.
+
+        "cert" must contain the certificate of the broker and if needed also
+        intermediate certificates. "key" must contain the private key of the
+        broker. If it password  protected, "password" must be specified as well.
+        "trusted" must contain the trusted certificates. In "client_auth" you can
+        specify whether authentication is requested, required or not needed at all.
+        """
+        super().__init__(image, **kwargs)
+        env = self.with_env
+        self.port = port
+        ssl = bool(cert or trusted or client_auth)
+        protocol = "SSL" if ssl else "PLAINTEXT"
+        self.protocol = protocol
+        self.with_exposed_ports(port)
+        self.broker_port = DEFAULT_PORT if port == BROKER_PORT else BROKER_PORT
+        listeners = f"{protocol}://0.0.0.0:{port},BROKER://0.0.0.0:{self.broker_port}"
+        protocol_map = f"BROKER:PLAINTEXT,{protocol}:{protocol}"
+        env("KAFKA_LISTENERS", listeners)
+        env("KAFKA_INTER_BROKER_LISTENER_NAME", "BROKER")
+        env("KAFKA_LISTENER_SECURITY_PROTOCOL_MAP", protocol_map)
+        env("KAFKA_BROKER_ID", "1")
+        env("KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR", "1")
+        env("KAFKA_OFFSETS_TOPIC_NUM_PARTITIONS", "1")
+        env("KAFKA_LOG_FLUSH_INTERVAL_MESSAGES", "10000000")
+        env("KAFKA_GROUP_INITIAL_REBALANCE_DELAY_MS", "0")
+        if ssl:
+            if cert:
+                cert = cert.strip().replace("\n", "\\n")
+            if key:
+                key = key.strip().replace("\n", "\\n")
+            if password:
+                password = password.strip().replace("\n", "\\n")
+            if trusted:
+                trusted = trusted.strip().replace("\n", "\\n")
+            if cert:
+                if not cert.startswith("-----BEGIN") or "CERTIFICATE" not in cert:
+                    raise ValueError("Certificate chain must be in PEM format")
+                env("KAFKA_SSL_KEYSTORE_CERTIFICATE_CHAIN", cert)
+            if key:
+                if not key.startswith("-----BEGIN") or "PRIVATE KEY" not in key:
+                    raise ValueError("Private key must be in PEM format")
+                env("KAFKA_SSL_KEYSTORE_KEY", key)
+            if cert or key:
+                env("KAFKA_SSL_KEYSTORE_TYPE", "PEM")
+            if key and password:
+                env("KAFKA_SSL_KEY_PASSWORD", password)
+            if trusted:
+                if not trusted.startswith("-----BEGIN") or "CERTIFICATE" not in trusted:
+                    raise ValueError("Trusted certificates must be in PEM format")
+                env("KAFKA_SSL_TRUSTSTORE_CERTIFICATES", trusted)
+                env("KAFKA_SSL_TRUSTSTORE_TYPE", "PEM")
+            if client_auth:
+                env("KAFKA_SSL_CLIENT_AUTH", client_auth)
+            env("KAFKA_SSL_ENDPOINT_IDENTIFICATION_ALGORITHM", " ")
+
+    def get_bootstrap_server(self) -> str:
+        """Get the Kafka bootstrap server."""
+        host = self.get_container_host_ip()
+        port = self.get_exposed_port(self.port)
+        return f"{host}:{port}"
+
+    def start(self) -> "KafkaSSLContainer":
+        """Start the Docker container."""
+        script = self.TC_START_SCRIPT
+        command = f'sh -c "while [ ! -f {script} ]; do sleep 0.1; done; sh {script}"'
+        self.with_command(command)
+        super().start()
+        self.tc_start()
+        self._connect()
+        return self
+
+    @wait_container_is_ready(
+        UnrecognizedBrokerVersion, NoBrokersAvailable, KafkaError, ValueError
+    )  # pyright: ignore
+    def _connect(self) -> None:
+        bootstrap_server = self.get_bootstrap_server()
+        try:
+            consumer = KafkaConsumer(
+                group_id="test",
+                bootstrap_servers=[bootstrap_server],
+                security_protocol=self.protocol,
+            )
+        except SSLError:
+            pass  # count this as connected
+        else:
+            if not consumer.bootstrap_connected():
+                raise KafkaError("Unable to connect with Kafka container!")
+
+    def tc_start(self) -> None:
+        """Start the test container."""
+        protocol = self.protocol
+        host = self.get_container_host_ip()
+        port = self.get_exposed_port(self.port)
+        listeners = f"{protocol}://{host}:{port},BROKER://127.0.0.1:{self.broker_port}"
+        script = f"""
+        #!/bin/bash
+        c=/etc/confluent/docker
+        . $c/bash-config
+        export KAFKA_ADVERTISED_LISTENERS={listeners}
+        export KAFKA_ZOOKEEPER_CONNECT=localhost:2181
+        p=zookeeper.properties
+        echo "clientPort=2181" > $p
+        echo "dataDir=/var/lib/zookeeper/data" >> $p
+        echo "dataLogDir=/var/lib/zookeeper/log" >> $p
+        zookeeper-server-start $p &
+        # workaround for https://github.com/confluentinc/kafka-images/issues/244
+        sed -i -E '/^if .*LISTENERS.*SSL:/,/^fi/d' $c/configure
+        $c/configure && $c/launch
+        """
+        self.create_file(dedent(script).strip().encode("utf-8"), self.TC_START_SCRIPT)
+
+    def create_file(self, content: bytes, path: str) -> None:
+        """Create a file inside the container."""
+        with BytesIO() as archive:
+            with tarfile.TarFile(fileobj=archive, mode="w") as tar:
+                tarinfo = tarfile.TarInfo(name=path)
+                tarinfo.size = len(content)
+                tarinfo.mtime = time.time()  # type: ignore
+                tar.addfile(tarinfo, BytesIO(content))
+            archive.seek(0)
+            self.get_wrapped_container().put_archive("/", archive)

{hexkit-0.11.1 → hexkit-1.1.0}/src/hexkit/providers/akafka/testutils.py

@@ -38,6 +38,7 @@ from hexkit.providers.akafka.provider import (
     KafkaEventPublisher,
     get_event_type,
 )
+from hexkit.providers.akafka.testcontainer import DEFAULT_IMAGE as KAFKA_IMAGE
 
 
 @dataclass(frozen=True)
@@ -61,7 +62,7 @@ class ExpectedEvent(EventBase):
 
 @dataclass(frozen=True)
 class RecordedEvent(EventBase):
-    """Used by the EventyRecorder class to describe events recorded in a specific topic."""
+    """Used by the EventRecorder class to describe events recorded in a specific topic."""
 
     key: Ascii
 
@@ -324,7 +325,7 @@ class EventRecorder:
         return self
 
     async def __aexit__(self, error_type, error_val, error_tb):
-        """Stop recording and check the recorded events agains the expectation when
+        """Stop recording and check the recorded events against the expectation when
         exiting the context block.
         """
         await self.stop_recording()
@@ -403,9 +404,9 @@ async def kafka_fixture_function() -> AsyncGenerator[KafkaFixture, None]:
 
     **Do not call directly** Instead, use get_kafka_fixture()
     """
-    with KafkaContainer(image="confluentinc/cp-kafka:5.4.9-1-deb8") as kafka:
+    with KafkaContainer(image=KAFKA_IMAGE) as kafka:
         kafka_servers = [kafka.get_bootstrap_server()]
-        config = KafkaConfig(
+        config = KafkaConfig(  # type: ignore
             service_name="test_publisher",
             service_instance_id="001",
             kafka_servers=kafka_servers,

{hexkit-0.11.1 → hexkit-1.1.0}/src/hexkit/providers/mongodb/provider.py

@@ -111,7 +111,7 @@ class MongoDbDaoBase(ABC, Generic[Dto]):
         Raises:
             ResourceNotFoundError: when resource with the specified id_ was not found
         """
-        document = await self._collection.find_one(  # type: ignore
+        document = await self._collection.find_one(
             {"_id": id_},
             session=self._session,
         )
@@ -406,7 +406,7 @@ class MongoDbDaoFactory(DaoFactoryProtocol):
         self._config = config
 
         # get a database-specific client:
-        self._client = AsyncIOMotorClient(
+        self._client = AsyncIOMotorClient(  # type: ignore
             self._config.db_connection_str.get_secret_value()
         )
         self._db = self._client[self._config.db_name]
@@ -428,7 +428,7 @@ class MongoDbDaoFactory(DaoFactoryProtocol):
         ...
 
     @overload
-    async def _get_dao(  # pylint: disable=arguments-differ
+    async def _get_dao(
         self,
         *,
         name: str,

{hexkit-0.11.1 → hexkit-1.1.0}/src/hexkit/providers/s3/provider.py

@@ -97,7 +97,6 @@ class S3Config(BaseSettings):
         description=(
             "Path to a config file for specifying more advanced S3 parameters."
             + " This should follow the format described here:"
-            # pylint: disable=line-too-long
             + " https://boto3.amazonaws.com/v1/documentation/api/latest/guide/configuration.html#using-a-configuration-file"
         ),
     )
@@ -114,12 +113,10 @@ def read_aws_config_ini(aws_config_ini: Path) -> botocore.config.Config:
     return botocore.config.Config(**config_profile)
 
 
-class S3ObjectStorage(
-    ObjectStorageProtocol
-):  # pylint: disable=too-many-instance-attributes
+class S3ObjectStorage(ObjectStorageProtocol):
     """S3-based provider implementing the ObjectStorageProtocol."""
 
-    def __init__(  # pylint: disable=too-many-arguments
+    def __init__(
         self,
         *,
         config: S3Config,
@@ -548,7 +545,6 @@ class S3ObjectStorage(
                 object_id=object_id,
             ) from error
 
-    # pylint: disable=too-many-arguments
     async def _check_uploaded_parts(
         self,
         *,
@@ -629,7 +625,6 @@ class S3ObjectStorage(
                     + f" first part which had only {first_part_size}.",
                 )
 
-    # pylint: disable=too-many-arguments
     async def _abort_multipart_upload(
         self,
         *,
@@ -686,7 +681,6 @@ class S3ObjectStorage(
                 upload_id=upload_id, bucket_id=bucket_id, object_id=object_id
             )
 
-    # pylint: disable=too-many-arguments
     async def _complete_multipart_upload(
         self,
         *,

{hexkit-0.11.1 → hexkit-1.1.0}/src/hexkit/providers/s3/testutils.py

@@ -200,7 +200,6 @@ def check_part_size(file_path: Path, anticipated_size: int) -> None:
         )
 
 
-# pylint: disable=too-many-arguments
 async def upload_part(
     storage_dao: ObjectStorageProtocol,
     upload_id: str,
@@ -220,7 +219,6 @@ async def upload_part(
     response.raise_for_status()
 
 
-# pylint: disable=too-many-arguments
 async def upload_part_of_size(
     storage_dao: ObjectStorageProtocol,
     upload_id: str,
@@ -372,7 +370,6 @@ async def prepare_non_completed_upload(s3_fixture_: S3Fixture):
 # This workflow is defined as a seperate function so that it can also be used
 # outside of the `tests` package e.g. to test the compliance of an S3-compatible
 # object storage implementation:
-# pylint: disable=too-many-arguments
 async def typical_workflow(
     storage_client: ObjectStorageProtocol,
     test_file_path: Path,

{hexkit-0.11.1 → hexkit-1.1.0}/src/hexkit/utils.py

@@ -16,7 +16,9 @@
 """General utilities that don't require heavy dependencies."""
 
 from collections.abc import Collection
-from typing import Optional
+from contextlib import asynccontextmanager
+from contextvars import ContextVar
+from typing import Any, Optional
 
 from pydantic import BaseModel
 
@@ -111,3 +113,14 @@ def validate_fields_in_model(
     if not fields_set.issubset(existing_fields_set):
         unexpected_fields = fields_set.difference(existing_fields_set)
         raise FieldNotInModelError(model=model, unexpected_field=unexpected_fields)
+
+
+@asynccontextmanager
+async def set_context_var(context_var: ContextVar, value: Any):
+    """An async context manager to simplify the use of ContextVars.
+
+    The value will be reset upon exiting the context.
+    """
+    token = context_var.set(value)
+    yield
+    context_var.reset(token)

{hexkit-0.11.1 → hexkit-1.1.0/src/hexkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hexkit
-Version: 0.11.1
+Version: 1.1.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
@@ -31,13 +31,13 @@ Provides-Extra: mongodb
 Requires-Dist: motor<4,>=3.1.1; extra == "mongodb"
 Provides-Extra: test-akafka
 Requires-Dist: hexkit[akafka]; extra == "test-akafka"
-Requires-Dist: testcontainers[kafka]<4,>=3.4.1; extra == "test-akafka"
+Requires-Dist: testcontainers[kafka]<4,>=3.7.1; extra == "test-akafka"
 Provides-Extra: test-s3
 Requires-Dist: hexkit[s3]; extra == "test-s3"
-Requires-Dist: testcontainers<4,>=3.4.1; extra == "test-s3"
+Requires-Dist: testcontainers<4,>=3.7.1; extra == "test-s3"
 Provides-Extra: test-mongodb
 Requires-Dist: hexkit[mongodb]; extra == "test-mongodb"
-Requires-Dist: testcontainers[mongo]<4,>=3.4.1; extra == "test-mongodb"
+Requires-Dist: testcontainers[mongo]<4,>=3.7.1; extra == "test-mongodb"
 Provides-Extra: test
 Requires-Dist: hexkit[test-akafka,test-mongodb,test-s3]; extra == "test"
 Provides-Extra: all

{hexkit-0.11.1 → hexkit-1.1.0}/src/hexkit.egg-info/SOURCES.txt

@@ -1,10 +1,12 @@
 LICENSE
+MANIFEST.in
 README.md
 pyproject.toml
 src/hexkit/__init__.py
 src/hexkit/__main__.py
 src/hexkit/base.py
 src/hexkit/config.py
+src/hexkit/correlation.py
 src/hexkit/custom_types.py
 src/hexkit/inject.py
 src/hexkit/utils.py
@@ -21,6 +23,7 @@ src/hexkit/protocols/objstorage.py
 src/hexkit/providers/__init__.py
 src/hexkit/providers/akafka/__init__.py
 src/hexkit/providers/akafka/provider.py
+src/hexkit/providers/akafka/testcontainer.py
 src/hexkit/providers/akafka/testutils.py
 src/hexkit/providers/mongodb/__init__.py
 src/hexkit/providers/mongodb/provider.py

{hexkit-0.11.1 → hexkit-1.1.0}/src/hexkit.egg-info/requires.txt

@@ -22,12 +22,12 @@ hexkit[test-akafka,test-mongodb,test-s3]
 
 [test-akafka]
 hexkit[akafka]
-testcontainers[kafka]<4,>=3.4.1
+testcontainers[kafka]<4,>=3.7.1
 
 [test-mongodb]
 hexkit[mongodb]
-testcontainers[mongo]<4,>=3.4.1
+testcontainers[mongo]<4,>=3.7.1
 
 [test-s3]
 hexkit[s3]
-testcontainers<4,>=3.4.1
+testcontainers<4,>=3.7.1