hexkit 0.10.2__tar.gz → 0.11.1__tar.gz

{hexkit-0.10.2 → hexkit-0.11.1}/PKG-INFO

@@ -1,11 +1,10 @@
 Metadata-Version: 2.1
 Name: hexkit
-Version: 0.10.2
+Version: 0.11.1
 Summary: A Toolkit for Building Microservices using the Hexagonal Architecture
-Home-page: https://github.com/ghga-de/hexkit
-Author: German Human Genome Phenome Archive (GHGA)
-Author-email: contact@ghga.de
+Author-email: "German Human Genome Phenome Archive (GHGA)" <contact@ghga.de>
 License: Apache 2.0
+Project-URL: Repository, https://github.com/ghga-de/hexkit
 Classifier: Development Status :: 1 - Planning
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Programming Language :: Python :: 3.9
@@ -16,16 +15,33 @@ Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Intended Audience :: Developers
 Requires-Python: >=3.9
-Description-Content-Type: text/markdown; charset=UTF-8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic<3,>=2
+Requires-Dist: pydantic_settings<3,>=2
+Requires-Dist: PyYAML<7,>=6.0
+Requires-Dist: dependency-injector<5,>=4.41.0
 Provides-Extra: akafka
+Requires-Dist: aiokafka~=0.8.0; extra == "akafka"
+Requires-Dist: jsonschema<5,>=4.17.3; extra == "akafka"
 Provides-Extra: s3
+Requires-Dist: boto3<2,>=1.26.50; extra == "s3"
+Requires-Dist: botocore<2,>=1.29.50; extra == "s3"
 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"
 Provides-Extra: test-s3
+Requires-Dist: hexkit[s3]; extra == "test-s3"
+Requires-Dist: testcontainers<4,>=3.4.1; extra == "test-s3"
 Provides-Extra: test-mongodb
-Provides-Extra: test-all
+Requires-Dist: hexkit[mongodb]; extra == "test-mongodb"
+Requires-Dist: testcontainers[mongo]<4,>=3.4.1; extra == "test-mongodb"
+Provides-Extra: test
+Requires-Dist: hexkit[test-akafka,test-mongodb,test-s3]; extra == "test"
 Provides-Extra: all
-License-File: LICENSE
+Requires-Dist: hexkit[test]; extra == "all"
 
 ![tests](https://github.com/ghga-de/hexkit/actions/workflows/unit_and_int_tests.yaml/badge.svg)
 [![PyPI version shields.io](https://img.shields.io/pypi/v/hexkit.svg)](https://pypi.python.org/pypi/hexkit/)

hexkit-0.11.1/pyproject.toml

@@ -0,0 +1,52 @@
+[build-system]
+requires = ["setuptools>=67.7.2"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "hexkit"
+version = "0.11.1"
+description = "A Toolkit for Building Microservices using the Hexagonal Architecture"
+readme = "README.md"
+authors = [
+    { name = "German Human Genome Phenome Archive (GHGA)", email = "contact@ghga.de" },
+]
+requires-python = ">=3.9"
+license = { text = "Apache 2.0" }
+classifiers = [
+    "Development Status :: 1 - Planning",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "License :: OSI Approved :: Apache Software License",
+    "Topic :: Internet :: WWW/HTTP :: HTTP Servers",
+    "Topic :: Software Development :: Libraries",
+    "Intended Audience :: Developers",
+]
+dependencies = [
+    "pydantic >=2, <3",
+    "pydantic_settings >=2, <3",
+    "PyYAML >=6.0, <7",
+    "dependency-injector >=4.41.0, <5",
+]
+
+[project.optional-dependencies]
+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 = ["hexkit[test-akafka,test-s3,test-mongodb]"]
+
+all = ["hexkit[test]"]
+
+[project.urls]
+Repository = "https://github.com/ghga-de/hexkit"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+"hexkit.providers.s3.test_files" = ["*.yaml"]

hexkit-0.11.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

{hexkit-0.10.2 → hexkit-0.11.1/src}/hexkit/__init__.py

@@ -15,4 +15,6 @@
 
 """A Toolkit for Building Microservices using the Hexagonal Architecture"""
 
-__version__ = "0.10.2"
+from importlib.metadata import version
+
+__version__ = version(__package__)

{hexkit-0.10.2 → hexkit-0.11.1/src}/hexkit/config.py

@@ -17,10 +17,14 @@
 
 import os
 from pathlib import Path
-from typing import Any, Callable, Dict, Final, Optional
+from typing import Any, Callable, Final, Optional
 
 import yaml
-from pydantic import BaseSettings
+from pydantic_settings import (
+    BaseSettings,
+    PydanticBaseSettingsSource,
+    SettingsConfigDict,
+)
 
 # Default config prefix:
 DEFAULT_CONFIG_PREFIX: Final = "ghga_services"
@@ -77,7 +81,7 @@ def get_default_config_yaml(prefix: str) -> Optional[Path]:
 
 def yaml_settings_factory(
     config_yaml: Optional[Path] = None,
-) -> Callable[[BaseSettings], Dict[str, Any]]:
+) -> Callable[[], dict[str, Any]]:
     """
     A factory of source methods for pydantic's BaseSettings Config that load
     settings from a yaml file.
@@ -87,14 +91,12 @@ def yaml_settings_factory(
             Path to the yaml file to read from.
     """
 
-    def yaml_settings(  # pylint: disable=unused-argument
-        settings: BaseSettings,
-    ) -> Dict[str, Any]:
-        """source method for loading pydantic BaseSettings from a yaml file"""
+    def yaml_settings() -> dict[str, Any]:
+        """Source method for loading pydantic BaseSettings from a yaml file"""
         if config_yaml is None:
             return {}
 
-        with open(config_yaml, "r", encoding="utf8") as yaml_file:
+        with open(config_yaml, encoding="utf8") as yaml_file:
             return yaml.safe_load(yaml_file)
 
     return yaml_settings
@@ -105,8 +107,8 @@ def config_from_yaml(
 ) -> Callable:
     """A factory that returns decorator functions which extends a
     pydantic BaseSettings class to read in parameters from a config yaml.
-    It replaces (or adds) a Config subclass to the BaseSettings class that configures
-    the priorities for parameter sources as follows (highest Priority first):
+    It replaces (or adds) config settings to the BaseSettings class that configures
+    the priorities for parameter sources as follows (highest priority first):
         - parameters passed using **kwargs
         - environment variables
         - file secrets
@@ -136,11 +138,10 @@ def config_from_yaml(
             settings (BaseSettings):
                 A pydantic BaseSettings class to be modified.
         """
-
         # check if settings inherits from pydantic BaseSettings:
         if not issubclass(settings, BaseSettings):
             raise TypeError(
-                "The specified settings class is not a subclass of pydantic.BaseSettings"
+                "The specified settings class is not a subclass of pydantic_settings.BaseSettings"
             )
 
         def constructor_wrapper(
@@ -153,41 +154,33 @@ def config_from_yaml(
                 config_yaml (str, optional):
                     Path to a config yaml. Overwrites the default location.
             """
-
             # get default path if config_yaml not specified:
             if config_yaml is None:
                 config_yaml = get_default_config_yaml(prefix)
-            else:
-                if not config_yaml.is_file():
-                    raise ConfigYamlDoesNotExist(path=config_yaml)
+            elif not config_yaml.is_file():
+                raise ConfigYamlDoesNotExist(path=config_yaml)
 
             class ModSettings(settings):
                 """Modifies the orginal Settings class provided by the user"""
 
-                # pylint: disable=too-few-public-methods
-                class Config:
-                    """pydantic Config subclass"""
-
-                    frozen = True
-
-                    # add this prefix to all variable names to
-                    # define them as environment variables:
-                    env_prefix = f"{prefix}_"
-
-                    @classmethod
-                    def customise_sources(
-                        cls,
+                model_config = SettingsConfigDict(frozen=True, env_prefix=f"{prefix}_")
+
+                @classmethod
+                def settings_customise_sources(  # noqa: PLR0913
+                    cls,
+                    settings_cls: type[BaseSettings],
+                    init_settings: PydanticBaseSettingsSource,
+                    env_settings: PydanticBaseSettingsSource,
+                    dotenv_settings: PydanticBaseSettingsSource,
+                    file_secret_settings: PydanticBaseSettingsSource,
+                ):
+                    """Add custom yaml source"""
+                    return (
                         init_settings,
                         env_settings,
                         file_secret_settings,
-                    ):
-                        """add custom yaml source"""
-                        return (
-                            init_settings,
-                            env_settings,
-                            file_secret_settings,
-                            yaml_settings_factory(config_yaml),
-                        )
+                        yaml_settings_factory(config_yaml),
+                    )
 
             # construct settings class:
             return ModSettings(**kwargs)

{hexkit-0.10.2 → hexkit-0.11.1/src}/hexkit/custom_types.py

@@ -17,7 +17,7 @@
 """Module collecting custom types."""
 
 from collections.abc import Mapping, Sequence
-from typing import Any, Union
+from typing import Any, Literal, Union
 
 # This is intended to type objects that could be a potential output of `json.loads`.
 # (Scalar types as well as arrays are excluded from the above assumption.)
@@ -74,3 +74,7 @@ AsyncConstructable = Any
 # ```
 # Thus using a type alias for now:
 AsyncContextConstructable = Any
+
+
+# The possible scopes for pytest fixtures
+PytestScope = Literal["session", "package", "module", "class", "function"]

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

@@ -33,7 +33,7 @@ from typing import Any, Callable, Generic, Optional, TypeVar, Union
 
 import dependency_injector.containers
 import dependency_injector.providers
-from pydantic import BaseSettings
+from pydantic_settings import BaseSettings
 
 from hexkit.custom_types import AsyncConstructable, AsyncContextConstructable
 
@@ -55,7 +55,8 @@ class NotConstructableError(TypeError):
 
 class AsyncInitShutdownError(TypeError):
     """Thrown when a container has sync `init_resource` or `shutdown_resource` methods
-    but coroutines are needed."""
+    but coroutines are needed.
+    """
 
 
 def assert_async_constructable(
@@ -68,7 +69,6 @@ def assert_async_constructable(
     not check whether `construct` really returns an awaitable or an async context
     manager.
     """
-
     if not callable(getattr(constructable, "construct", None)):
         raise NotConstructableError(
             "Async(Context)Constructable class must have a callable `construct` attribute."
@@ -77,7 +77,8 @@ def assert_async_constructable(
 
 class AsyncConstructor(dependency_injector.providers.Resource):
     """Maps an Async(Context)Constructable onto the Resource class from the
-    `dependency_injector` framework."""
+    `dependency_injector` framework.
+    """
 
     @staticmethod
     def constructable_to_resource(
@@ -87,7 +88,6 @@ class AsyncConstructor(dependency_injector.providers.Resource):
         Converts an Async(Context)Constructable to an async generator that is compatible
         with the Resource definition of the `dependency_injector` framework.
         """
-
         assert_async_constructable(constructable)
 
         async def resource(*args: Any, **kwargs: Any) -> AsyncIterator[Any]:
@@ -120,7 +120,6 @@ class AsyncConstructor(dependency_injector.providers.Resource):
         **kwargs: dependency_injector.providers.Injection,
     ):
         """Initialize `dependency_injector`'s Resource with an AbstractAsyncContextManager."""
-
         if provides is None:
             super().__init__()
         else:
@@ -130,8 +129,8 @@ class AsyncConstructor(dependency_injector.providers.Resource):
 
 def get_constructor(provides: type, *args, **kwargs):
     """Automatically selects and applies the right constructor for the class given to
-    `provides`."""
-
+    `provides`.
+    """
     constructor_cls: type
 
     try:
@@ -148,11 +147,11 @@ def get_constructor(provides: type, *args, **kwargs):
 
 class CMDynamicContainer(dependency_injector.containers.DynamicContainer):
     """Adds a async context manager interface to the DynamicContainer base class from
-    the `dependency_injector` framework."""
+    the `dependency_injector` framework.
+    """
 
     async def __aenter__(self):
         """Init/setup resources."""
-
         init_future = self.init_resources()
 
         if not inspect.isawaitable(init_future):
@@ -165,7 +164,6 @@ class CMDynamicContainer(dependency_injector.containers.DynamicContainer):
 
     async def __aexit__(self, exc_type, exc_value, exc_trace):
         """Shutdown/teardown resources"""
-
         shutdown_future = self.shutdown_resources()
 
         if not inspect.isawaitable(shutdown_future):
@@ -206,11 +204,11 @@ PydanticConfig = TypeVar("PydanticConfig", bound=BaseSettings)
 
 class Configurator(dependency_injector.providers.Factory, Generic[PydanticConfig]):
     """A configuration constructor that holds configuration parameters using a pydantic
-    model."""
+    model.
+    """
 
     def load_config(self, config: PydanticConfig):
         """Loading config parameters form an pydantic config instance."""
-
         self.override(dependency_injector.providers.Callable(lambda: config))
 
 
@@ -220,6 +218,6 @@ def get_configurator(
     """Initializes a configuration provider.
 
     This helper function is necessary because the __init__ of Providers used by the
-    dependency_injector framework need to always use the same signature."""
-
+    dependency_injector framework need to always use the same signature.
+    """
     return Configurator[PydanticConfig](pydantic_cls)

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

@@ -15,7 +15,10 @@
 #
 
 """Protocol for creating Data Access Objects to perform CRUD (plus find) interactions
-with the database."""
+with the database.
+"""
+
+# ruff: noqa: PLR0913
 
 import typing
 from abc import ABC, abstractmethod
@@ -72,7 +75,8 @@ class InvalidFindMappingError(FindError):
 
 class MultipleHitsFoundError(FindError):
     """Raised when a DAO find operation did result in multiple hits while only a
-    single hit was expected."""
+    single hit was expected.
+    """
 
     def __init__(self, *, mapping: Mapping[str, str]):
         message = (
@@ -84,7 +88,8 @@ class MultipleHitsFoundError(FindError):
 
 class NoHitsFoundError(FindError):
     """Raised when a DAO find operation did result in no hits while a
-    single hit was expected."""
+    single hit was expected.
+    """
 
     def __init__(self, *, mapping: Mapping[str, str]):
         message = (
@@ -259,7 +264,6 @@ async def uuid4_id_generator() -> AsyncGenerator[str, None]:
     This is an AsyncGenerator to be compliant with the id_generator requirements of the
     DaoFactoryProtocol.
     """
-
     while True:
         yield str(uuid4())
 
@@ -274,7 +278,8 @@ class DaoFactoryProtocol(ABC):
 
     class CreationModelInvalidError(ValueError):
         """Raised when the DtoCreationModel was invalid in relation to the main
-        DTO model."""
+        DTO model.
+        """
 
     class IndexFieldsInvalidError(ValueError):
         """Raised when providing an invalid list of fields to index."""
@@ -282,9 +287,9 @@ class DaoFactoryProtocol(ABC):
     @classmethod
     def _validate_dto_model_id(cls, *, dto_model: type[Dto], id_field: str) -> None:
         """Checks whether the dto_model contains the expected id_field.
-        Raises IdFieldNotFoundError otherwise."""
-
-        if id_field not in dto_model.schema()["properties"]:
+        Raises IdFieldNotFoundError otherwise.
+        """
+        if id_field not in dto_model.model_json_schema()["properties"]:
             raise cls.IdFieldNotFoundError()
 
     @classmethod
@@ -296,16 +301,16 @@ class DaoFactoryProtocol(ABC):
         id_field: str,
     ) -> None:
         """Checks that the dto_creation_model has the same fields as the dto_model
-        except missing the ID. Raises CreationModelInvalidError otherwise."""
-
+        except missing the ID. Raises CreationModelInvalidError otherwise.
+        """
         if dto_creation_model is None:
             return
 
-        expected_properties = copy(dto_model.schema()["properties"])
+        expected_properties = copy(dto_model.model_json_schema()["properties"])
         # (the schema method returns an attribute of the class, making a copy to not
         # alter the class)
         del expected_properties[id_field]
-        observed_properties = dto_creation_model.schema()["properties"]
+        observed_properties = dto_creation_model.model_json_schema()["properties"]
 
         if observed_properties != expected_properties:
             raise cls.CreationModelInvalidError()
@@ -318,8 +323,8 @@ class DaoFactoryProtocol(ABC):
         fields_to_index: Optional[Collection[str]],
     ) -> None:
         """Checks that all provided fields are present in the dto_model.
-        Raises IndexFieldsInvalidError otherwise."""
-
+        Raises IndexFieldsInvalidError otherwise.
+        """
         if fields_to_index is None:
             return
 
@@ -403,7 +408,6 @@ class DaoFactoryProtocol(ABC):
             self.IdFieldNotFoundError:
                 Raised when the dto_model did not contain the expected id_field.
         """
-
         self._validate_dto_model_id(dto_model=dto_model, id_field=id_field)
 
         self._validate_dto_creation_model(
@@ -417,7 +421,7 @@ class DaoFactoryProtocol(ABC):
         )
 
         if id_generator is None:
-            # instanciate the default ID generator:
+            # instantiate the default ID generator:
             id_generator = uuid4_id_generator()
 
         return await self._get_dao(
@@ -470,5 +474,6 @@ class DaoFactoryProtocol(ABC):
         id_generator: AsyncGenerator[str, None],
     ) -> Union[DaoSurrogateId[Dto, DtoCreation], DaoNaturalId[Dto]]:
         """*To be implemented by the provider. Input validation is done outside of this
-        method.*"""
+        method.*
+        """
         ...

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

@@ -16,6 +16,7 @@
 
 """Protocol for interacting with S3-like Object Storages."""
 
+# ruff: noqa: PLR0913
 
 import re
 from abc import ABC, abstractmethod
@@ -28,16 +29,15 @@ DEFAULT_URL_EXPIRATION_PERIOD = 24 * 60 * 60  # default expiration time 24 hours
 
 class PresignedPostURL(NamedTuple):
     """Container for presigned POST URLs along with additional metadata fields that
-    should be attached as body data when sending the POST request."""
+    should be attached as body data when sending the POST request.
+    """
 
     url: str
     fields: dict[str, str]
 
 
 class ObjectStorageProtocol(ABC):
-    """
-    Protocol for interacting with S3-like Object Storages.
-    """
+    """Protocol for interacting with S3-like Object Storages."""
 
     # constants for multipart uploads:
     # (shall not be changed by provider implementations)
@@ -51,7 +51,6 @@ class ObjectStorageProtocol(ABC):
         """Check whether a bucket with the specified ID (`bucket_id`) exists.
         Returns `True` if it exists and `False` otherwise.
         """
-
         self._validate_bucket_id(bucket_id)
         return await self._does_bucket_exist(bucket_id)
 
@@ -60,7 +59,6 @@ class ObjectStorageProtocol(ABC):
         Create a bucket (= a structure that can hold multiple file objects) with the
         specified unique ID.
         """
-
         self._validate_bucket_id(bucket_id)
         await self._create_bucket(bucket_id)
 
@@ -73,14 +71,11 @@ class ObjectStorageProtocol(ABC):
         will be deleted, if False (the default) a BucketNotEmptyError will be raised if
         the bucket is not empty.
         """
-
         self._validate_bucket_id(bucket_id)
         await self._delete_bucket(bucket_id, delete_content=delete_content)
 
     async def list_all_object_ids(self, bucket_id: str) -> list[str]:
-        """
-        Retrieve a list of IDs for all objects currently present in the specified bucket
-        """
+        """Retrieve a list of IDs for all objects currently present in the specified bucket"""
         self._validate_bucket_id(bucket_id)
         return await self._list_all_object_ids(bucket_id=bucket_id)
 
@@ -97,7 +92,6 @@ class ObjectStorageProtocol(ABC):
         You may also specify a custom expiry duration in seconds (`expires_after`) and
         a maximum size (bytes) for uploads (`max_upload_size`).
         """
-
         self._validate_bucket_id(bucket_id)
         self._validate_object_id(object_id)
         return await self._get_object_upload_url(
@@ -114,7 +108,6 @@ class ObjectStorageProtocol(ABC):
         object_id: str,
     ) -> str:
         """Initiates a multipart upload procedure. Returns the upload ID."""
-
         self._validate_bucket_id(bucket_id)
         self._validate_object_id(object_id)
         return await self._init_multipart_upload(
@@ -136,7 +129,6 @@ class ObjectStorageProtocol(ABC):
         Please note: the part number must be a non-zero, positive integer and parts
         should be uploaded in sequence.
         """
-
         self._validate_bucket_id(bucket_id)
         self._validate_object_id(object_id)
         return await self._get_part_upload_url(
@@ -157,7 +149,6 @@ class ObjectStorageProtocol(ABC):
         """Cancel a multipart upload with the specified ID. All uploaded content is
         deleted.
         """
-
         self._validate_bucket_id(bucket_id)
         self._validate_object_id(object_id)
         await self._abort_multipart_upload(
@@ -180,7 +171,6 @@ class ObjectStorageProtocol(ABC):
         This ensures that exactly the specified number of parts exist and that all parts
         (except the last one) have the specified size.
         """
-
         self._validate_bucket_id(bucket_id)
         self._validate_object_id(object_id)
         await self._complete_multipart_upload(
@@ -198,7 +188,6 @@ class ObjectStorageProtocol(ABC):
         the specified ID (`object_id`) from bucket with the specified id (`bucket_id`).
         You may also specify a custom expiry duration in seconds (`expires_after`).
         """
-
         self._validate_bucket_id(bucket_id)
         self._validate_object_id(object_id)
         return await self._get_object_download_url(
@@ -213,7 +202,6 @@ class ObjectStorageProtocol(ABC):
         may be provided to check the objects content.
         Returns `True` if checks succeed and `False` otherwise.
         """
-
         self._validate_bucket_id(bucket_id)
         self._validate_object_id(object_id)
         return await self._does_object_exist(
@@ -221,10 +209,7 @@ class ObjectStorageProtocol(ABC):
         )
 
     async def get_object_size(self, *, bucket_id: str, object_id: str) -> int:
-        """
-        Returns the size of an object in bytes.
-        """
-
+        """Returns the size of an object in bytes."""
         self._validate_bucket_id(bucket_id)
         self._validate_object_id(object_id)
         return await self._get_object_size(bucket_id=bucket_id, object_id=object_id)
@@ -240,7 +225,6 @@ class ObjectStorageProtocol(ABC):
         """Copy an object from one bucket (`source_bucket_id` and `source_object_id`) to
         another bucket (`dest_bucket_id` and `dest_object_id`).
         """
-
         self._validate_bucket_id(source_bucket_id)
         self._validate_object_id(source_object_id)
         self._validate_bucket_id(dest_bucket_id)
@@ -256,7 +240,6 @@ class ObjectStorageProtocol(ABC):
         """Delete an object with the specified id (`object_id`) in the bucket with the
         specified id (`bucket_id`).
         """
-
         self._validate_bucket_id(bucket_id)
         self._validate_object_id(object_id)
         await self._delete_object(bucket_id=bucket_id, object_id=object_id)
@@ -601,7 +584,8 @@ class ObjectStorageProtocol(ABC):
 
     class MultiPartUploadAlreadyExistsError(MultiPartUploadError):
         """Thrown when trying to create a multipart upload for an object for which another
-        upload is already active."""
+        upload is already active.
+        """
 
         def __init__(self, bucket_id: str, object_id: str):
             message = (

{hexkit-0.10.2 → hexkit-0.11.1/src}/hexkit/providers/akafka/__init__.py

@@ -19,7 +19,10 @@ They correspond to the `EventPublisherProtocol` and `EventSubscriberProtocol`,
 respectively.
 """
 
-from .provider import KafkaEventPublisher  # noqa: F401
-from .provider import KafkaConfig, KafkaEventSubscriber
+from .provider import (
+    KafkaConfig,
+    KafkaEventPublisher,
+    KafkaEventSubscriber,
+)
 
 __all__ = ["KafkaEventPublisher", "KafkaEventSubscriber", "KafkaConfig"]