hexkit 4.0.0__tar.gz → 4.1.1__tar.gz

{hexkit-4.0.0/src/hexkit.egg-info → hexkit-4.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: hexkit
-Version: 4.0.0
+Version: 4.1.1
 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-4.0.0 → hexkit-4.1.1}/pyproject.toml

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

{hexkit-4.0.0 → hexkit-4.1.1}/src/hexkit/log.py

@@ -118,13 +118,17 @@ class JsonFormatter(Formatter):
         output["details"] = log_record["details"]
 
         if log_record["exc_info"]:
-            exc_type, exc_value = log_record["exc_info"][:2]
+            exc_info = log_record["exc_info"]
+            exc_type, exc_value = exc_info[:2]
             exception = {
                 "type": exc_type.__name__,
                 "message": str(exc_value),
             }
             if self._include_traceback:
                 exc_text = log_record["exc_text"]
+                if not exc_text:
+                    # if there is not pre-formatted cached traceback, create it
+                    exc_text = super().formatException(exc_info)
                 if exc_text:
                     exception["traceback"] = exc_text
             output["exception"] = exception

{hexkit-4.0.0 → hexkit-4.1.1}/src/hexkit/providers/akafka/__init__.py

@@ -21,12 +21,14 @@ respectively.
 
 from .config import KafkaConfig
 from .provider import (
+    ComboTranslator,
     KafkaEventPublisher,
     KafkaEventSubscriber,
     KafkaOutboxSubscriber,
 )
 
 __all__ = [
+    "ComboTranslator",
     "KafkaConfig",
     "KafkaEventPublisher",
     "KafkaEventSubscriber",

{hexkit-4.0.0 → hexkit-4.1.1}/src/hexkit/providers/akafka/provider/__init__.py

@@ -22,6 +22,7 @@ Require dependencies of the `akafka` extra.
 from .daosub import KafkaOutboxSubscriber
 from .eventpub import KafkaEventPublisher
 from .eventsub import (
+    ComboTranslator,
     ConsumerEvent,
     ExtractedEventInfo,
     KafkaEventSubscriber,
@@ -29,6 +30,7 @@ from .eventsub import (
 )
 
 __all__ = [
+    "ComboTranslator",
     "ConsumerEvent",
     "ExtractedEventInfo",
     "KafkaEventPublisher",

{hexkit-4.0.0 → hexkit-4.1.1}/src/hexkit/providers/akafka/provider/daosub.py

@@ -24,85 +24,29 @@ from contextlib import asynccontextmanager
 from typing import Optional
 
 from aiokafka import AIOKafkaConsumer
-from pydantic import ValidationError
 
 from hexkit.base import InboundProviderBase
-from hexkit.custom_types import Ascii, JsonObject
-from hexkit.protocols.daosub import (
-    DaoSubscriberProtocol,
-    DtoValidationError,
-)
+from hexkit.protocols.daosub import DaoSubscriberProtocol
 from hexkit.protocols.eventpub import EventPublisherProtocol
-from hexkit.protocols.eventsub import EventSubscriberProtocol
 from hexkit.providers.akafka.config import KafkaConfig
 from hexkit.providers.akafka.provider.eventsub import (
+    CHANGE_EVENT_TYPE,  # noqa: F401  (export for backwards compatibility until v5)
+    DELETE_EVENT_TYPE,  # noqa: F401  (export for backwards compatibility until v5)
     KafkaConsumerCompatible,
     KafkaEventSubscriber,
 )
-
-CHANGE_EVENT_TYPE = "upserted"
-DELETE_EVENT_TYPE = "deleted"
-
-
-class TranslatorConverter(EventSubscriberProtocol):
-    """Takes a list of translators implementing the `DaoSubscriberProtocol` to
-    create a single translator implementing the `EventSubscriberProtocol`.
-    """
-
-    types_of_interest = [CHANGE_EVENT_TYPE, DELETE_EVENT_TYPE]
-
-    def __init__(self, *, translators: Sequence[DaoSubscriberProtocol]):
-        self.topics_of_interest = [translator.event_topic for translator in translators]
-
-        if len(set(self.topics_of_interest)) != len(self.topics_of_interest):
-            raise ValueError(
-                "Got multiple DaoSubscriberProtocol-compliant translators trying to"
-                + " consume from the same event topic."
-            )
-
-        self._translator_by_topic = {
-            translator.event_topic: translator for translator in translators
-        }
-
-    async def _consume_validated(
-        self, *, payload: JsonObject, type_: Ascii, topic: Ascii, key: Ascii
-    ) -> None:
-        """
-        Receive and process an event with already validated topic, type, and key.
-
-        Args:
-            payload: The data/payload to send with the event.
-            type_: The type of the event.
-            topic: Name of the topic the event was published to.
-            key: A key used for routing the event.
-        """
-        translator = self._translator_by_topic.get(topic)
-
-        if translator is None:
-            # This should never happen, as the topic should have been filtered out:
-            raise RuntimeError
-
-        if type_ == CHANGE_EVENT_TYPE:
-            try:
-                dto = translator.dto_model.model_validate(payload)
-            except ValidationError as error:
-                message = (
-                    f"The event of type {type_} on topic {topic}"
-                    + " was not valid wrt. the DTO model."
-                )
-                logging.error(message)
-                raise DtoValidationError(message) from error
-
-            await translator.changed(resource_id=key, update=dto)
-
-        else:
-            # a deletion event:
-            await translator.deleted(resource_id=key)
+from hexkit.providers.akafka.provider.eventsub import (
+    ComboTranslator as TranslatorConverter,  # for backwards compatibility
+)
 
 
 class KafkaOutboxSubscriber(InboundProviderBase):
     """Apache Kafka-specific provider using translators that implement the
     `DaoSubscriberProtocol`.
+
+    Note: this class can be replaced by using the ComboTranslator in conjunction
+    with the normal KafkaEventSubscriber class. We may therefore deprecate this
+    class in the near future.
     """
 
     @classmethod

{hexkit-4.0.0 → hexkit-4.1.1}/src/hexkit/providers/akafka/provider/eventsub.py

@@ -25,16 +25,20 @@ import asyncio
 import json
 import logging
 import ssl
+from collections import defaultdict
+from collections.abc import Sequence
 from contextlib import asynccontextmanager
 from dataclasses import asdict, dataclass
 from datetime import datetime, timezone
 from typing import Any, Callable, Literal, Optional, Protocol, TypeVar, Union, cast
 
 from aiokafka import AIOKafkaConsumer
+from pydantic import ValidationError
 
 from hexkit.base import InboundProviderBase
 from hexkit.correlation import set_correlation_id
 from hexkit.custom_types import Ascii, JsonObject
+from hexkit.protocols.daosub import DaoSubscriberProtocol, DtoValidationError
 from hexkit.protocols.eventpub import EventPublisherProtocol
 from hexkit.protocols.eventsub import DLQSubscriberProtocol, EventSubscriberProtocol
 from hexkit.providers.akafka.config import KafkaConfig
@@ -43,6 +47,107 @@ from hexkit.providers.akafka.provider.utils import (
     generate_ssl_context,
 )
 
+CHANGE_EVENT_TYPE = "upserted"
+DELETE_EVENT_TYPE = "deleted"
+EventOrDaoSubProtocol = Union[DaoSubscriberProtocol, EventSubscriberProtocol]
+
+
+class ComboTranslator(EventSubscriberProtocol):
+    """Takes a list of translators implementing either the `DaoSubscriberProtocol`,
+    `EventSubscriberProtocol`, or both, and create a single translator
+    implementing the `EventSubscriberProtocol`. This basically bundles the
+    passed-in translators, with the resulting combo translator acting as a router
+    that directs the event information to the appropriate translator based on
+    its `topic` and `type`.
+    """
+
+    topics_of_interest: list[str]
+    types_of_interest: list[str]
+
+    def __init__(
+        self,
+        *,
+        translators: Sequence[EventOrDaoSubProtocol],
+    ):
+        self.translators: dict[str, dict[str, EventOrDaoSubProtocol]] = defaultdict(
+            dict
+        )
+        self.topics_of_interest = []
+        self.types_of_interest = []
+        uses_outbox = False
+
+        outbox_topics: list[str] = []
+        non_outbox_topics: list[str] = []
+        for translator in translators:
+            if isinstance(translator, DaoSubscriberProtocol):
+                outbox_topics.append(translator.event_topic)
+                self.translators[translator.event_topic][CHANGE_EVENT_TYPE] = translator
+                self.translators[translator.event_topic][DELETE_EVENT_TYPE] = translator
+                uses_outbox = True
+            elif isinstance(translator, EventSubscriberProtocol):
+                # This looks like a looping no-no, but in reality is only a handful of
+                #  iterations and it ensures we route the event to the right translator
+                self.types_of_interest.extend(translator.types_of_interest)
+                non_outbox_topics.extend(dict.fromkeys(translator.topics_of_interest))
+                for topic in translator.topics_of_interest:
+                    for type_ in translator.types_of_interest:
+                        if type_ in self.translators[topic]:
+                            raise ValueError(
+                                "Got multiple EventSubscriberProtocol-compliant"
+                                + " translators trying to consume from the same topic"
+                                + " and type."
+                            )
+                        self.translators[topic][type_] = translator
+        if uses_outbox:
+            self.types_of_interest.append(CHANGE_EVENT_TYPE)
+            self.types_of_interest.append(DELETE_EVENT_TYPE)
+
+        if len(set(outbox_topics)) != len(outbox_topics):
+            raise ValueError(
+                "Got multiple DaoSubscriberProtocol-compliant translators trying to"
+                + " consume from the same event topic."
+            )
+        self.topics_of_interest.extend(outbox_topics)
+        self.topics_of_interest.extend(non_outbox_topics)
+
+    async def _consume_validated(
+        self, *, payload: JsonObject, type_: Ascii, topic: Ascii, key: Ascii
+    ) -> None:
+        """
+        Receive and process an event with already validated topic, type, and key.
+
+        Args:
+            payload: The data/payload to send with the event.
+            type_: The type of the event.
+            topic: Name of the topic the event was published to.
+            key: A key used for routing the event.
+        """
+        translator = self.translators[topic][type_]
+
+        if translator is None:
+            # This should never happen, as the topic should have been filtered out:
+            raise RuntimeError
+
+        if isinstance(translator, DaoSubscriberProtocol):
+            if type_ == CHANGE_EVENT_TYPE:
+                try:
+                    dto = translator.dto_model.model_validate(payload)
+                except ValidationError as error:
+                    message = (
+                        f"The event of type {type_} on topic {topic}"
+                        + " was not valid wrt. the DTO model."
+                    )
+                    logging.error(message)
+                    raise DtoValidationError(message) from error
+
+                await translator.changed(resource_id=key, update=dto)
+
+            else:
+                # a deletion event:
+                await translator.deleted(resource_id=key)
+        else:
+            await translator.consume(payload=payload, type_=type_, topic=topic, key=key)
+
 
 class HeaderNames:
     """Encapsulated constants for event header values"""

{hexkit-4.0.0 → hexkit-4.1.1/src/hexkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: hexkit
-Version: 4.0.0
+Version: 4.1.1
 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