python-hexagonal 0.1.0__py3-none-any.whl

hexagonal/__init__.py

@@ -0,0 +1,2 @@
+def hello() -> str:
+    return "Hello from python-hexagonal!"

hexagonal/adapters/drivens/buses/base/__init__.py

@@ -0,0 +1,15 @@
+from .command_bus import BaseCommandBus
+from .event_bus import BaseEventBus
+from .infrastructure import BaseBusInfrastructure
+from .message_bus import MessageBus
+from .query import QueryBus
+from .utils import EVENT_BUS_RAISE_ERROR
+
+__all__ = [
+    "EVENT_BUS_RAISE_ERROR",
+    "BaseCommandBus",
+    "BaseEventBus",
+    "MessageBus",
+    "QueryBus",
+    "BaseBusInfrastructure",
+]

hexagonal/adapters/drivens/buses/base/command_bus.py

@@ -0,0 +1,69 @@
+from typing import Any, Mapping, Type
+
+from eventsourcing.utils import get_topic
+
+from hexagonal.domain import (
+    CloudMessage,
+    Command,
+    HandlerAlreadyRegistered,
+    HandlerNotRegistered,
+    TCommand,
+)
+from hexagonal.ports.drivens import ICommandBus, IMessageHandler, TManager
+
+from .message_bus import MessageBus
+
+
+class BaseCommandBus(ICommandBus[TManager], MessageBus[TManager]):
+    _handlers: dict[str, IMessageHandler[Any]]
+
+    def initialize(self, env: Mapping[str, str]) -> None:
+        self.__class__._handlers = {}
+        super().initialize(env)
+
+    def _get_name(self, command_type: Type[TCommand]) -> str:
+        return get_topic(command_type)
+
+    def _get_handlers(self, message: CloudMessage[TCommand]) -> list[str]:
+        return [self._get_name(message.payload.__class__)]
+
+    def _handle_message(self, message: CloudMessage[TCommand], handler: str) -> None:
+        f_handler = self._handlers.get(handler)
+        if f_handler:
+            f_handler.handle_message(message)
+        else:
+            raise HandlerNotRegistered(f"Command: {handler}")
+
+    def register_handler(
+        self, command_type: Type[TCommand], handler: IMessageHandler[TCommand]
+    ):
+        self.verify()
+        name = self._get_name(command_type)
+        if name in self._handlers:
+            raise HandlerAlreadyRegistered(f"Command: {name}")
+        self._handlers[name] = handler
+
+    def unregister_handler(self, command_type: Type[TCommand]):
+        self.verify()
+        name = self._get_name(command_type)
+        if name in self._handlers:
+            del self._handlers[name]
+        else:
+            raise HandlerNotRegistered(f"Command: {name}")
+
+    def dispatch(
+        self, command: TCommand | CloudMessage[TCommand], *, to_outbox: bool = False
+    ) -> None:
+        self.verify()
+        cmd = (
+            command
+            if not isinstance(command, Command)
+            else CloudMessage[command.__class__].new(command)  # type: ignore
+        )
+        if to_outbox:
+            self.outbox_repository.save(cmd)
+        else:
+            self.process_command(cmd)
+
+    def process_command(self, command: CloudMessage[TCommand]) -> None:
+        self._process_messages(command)

hexagonal/adapters/drivens/buses/base/event_bus.py

@@ -0,0 +1,160 @@
+import logging
+from typing import Any, Callable, Dict, List, Mapping, Type, overload
+
+from eventsourcing.utils import TopicError, get_topic, strtobool
+
+from hexagonal.domain import (
+    CloudMessage,
+    HandlerAlreadyRegistered,
+    HandlerNotRegistered,
+    TEvent,
+    TEvento,
+)
+from hexagonal.ports.drivens import IEventBus, IMessageHandler, TManager
+
+from .message_bus import MessageBus
+from .utils import EVENT_BUS_RAISE_ERROR
+
+logger = logging.getLogger(__name__)
+
+
+class HandlerError(Exception):
+    def __init__(
+        self,
+        evento: CloudMessage[TEvento],
+        handler: IMessageHandler[TEvent] | Callable[..., None],
+        error: Exception,
+    ):
+        super().__init__(f"""
+Error al Manejar Evento {evento.__class__.__name__}
+    handler: {
+            handler.__class__.__name__   # pyright: ignore[reportUnknownMemberType]
+            if isinstance(handler, IMessageHandler)
+            else handler.__name__ 
+        }   
+    evento: {evento.type}
+    datos: {evento.model_dump_json(indent=2)}
+    error: {error}
+    stacktrace: {error.__traceback__}
+        """)  # type: ignore  # noqa: E501
+
+
+class BaseEventBus(IEventBus[TManager], MessageBus[TManager]):
+    handlers: Dict[str, Dict[str, IMessageHandler[Any]]]
+    wait_list: Dict[str, List[Callable[..., None]]]
+
+    def initialize(self, env: Mapping[str, str]) -> None:
+        self.handlers = {}
+        self.wait_list = {}
+        self.raise_error = strtobool(env.get(EVENT_BUS_RAISE_ERROR, "false"))
+        super().initialize(env)
+
+    def _get_key(self, obj: Type[TEvent] | IMessageHandler[TEvent]) -> str:
+        if not isinstance(obj, IMessageHandler):
+            return get_topic(obj)
+        try:
+            return get_topic(obj.__class__)
+        except TopicError as e:
+            raise HandlerAlreadyRegistered(
+                f"Handler: {obj.__class__}, error: {e}"
+            ) from e
+
+    def subscribe(self, event_type: Type[TEvent], handler: IMessageHandler[TEvent]):
+        self.verify()
+        key_event = self._get_key(event_type)
+        handlers = self.handlers.get(key_event, {})
+        key_handler = self._get_key(handler)
+        if key_handler in handlers:
+            raise HandlerAlreadyRegistered(f"Event: {key_event}")
+        handlers[key_handler] = handler
+        self.handlers[key_event] = handlers
+
+    def unsubscribe(self, event_type: Type[TEvent], *handlers: IMessageHandler[TEvent]):
+        self.verify()
+        key_event = self._get_key(event_type)
+        if not handlers:
+            if key_event in self.handlers:
+                del self.handlers[key_event]
+            return
+        for handler in handlers:
+            key_handler = self._get_key(handler)
+            dict_handlers = self.handlers.get(key_event)
+            if not dict_handlers:
+                raise HandlerNotRegistered(f"Event: {key_event}")
+            if key_handler not in dict_handlers:
+                raise HandlerNotRegistered(f"Event: {key_event}")
+            del dict_handlers[key_handler]
+
+        if not list(self.handlers[key_event].values()):
+            del self.handlers[key_event]
+
+    def _wait_for(self, event_type: Type[TEvent], handler: Callable[[TEvent], None]):
+        name = self._get_key(event_type)
+        if name not in self.wait_list:
+            self.wait_list[name] = []
+        self.wait_list[name].append(handler)
+
+    def _handle_wait_list(self, event: TEvento):
+        event_type = type(event)
+        key = self._get_key(event_type)
+        wait_list = self.wait_list.get(key)
+        while wait_list:
+            if self.raise_error:
+                handler = wait_list.pop()
+                handler(event)
+            else:
+                try:
+                    handler = wait_list.pop()
+                    handler(event)
+                except Exception as e:
+                    raise HandlerError(event, handler, e) from e  # type: ignore
+
+    @overload
+    def wait_for_publish(
+        self, event_type: Type[TEvent], handler: Callable[[TEvent], None]
+    ) -> None: ...
+
+    @overload
+    def wait_for_publish(
+        self, event_type: Type[TEvent]
+    ) -> Callable[[Callable[[TEvent], None]], None]: ...
+
+    def wait_for_publish(
+        self, event_type: Type[TEvent], handler: Callable[[TEvent], None] | None = None
+    ) -> Callable[[Callable[[TEvent], None]], None] | None:
+        self.verify()
+        if handler:
+            return self._wait_for(event_type, handler)
+
+        def decorator(func: Callable[[TEvent], None]):
+            self._wait_for(event_type, func)
+
+        return decorator
+
+    def _get_handlers(self, message: CloudMessage[TEvento]) -> list[str]:
+        key_event = self._get_key(type(message.payload))
+        handlers = self.handlers.get(key_event, {})
+        return list(handlers.keys())
+
+    def _handle_message(self, message: CloudMessage[TEvento], handler: str) -> None:
+        handlers = self.handlers.get(self._get_key(type(message.payload)))
+        if not handlers or handler not in handlers:
+            raise HandlerNotRegistered(f"Event: {handler}")
+        try:
+            handlers[handler].handle_message(message)
+        except Exception as e:
+            if self.raise_error:
+                logger.exception(
+                    "Error al Manejar Evento %s, con handler %s", message, handler
+                )
+                raise
+            raise HandlerError(message, handlers[handler], e) from e
+
+    def _publish_message(self, message: CloudMessage[TEvento]) -> None:
+        try:
+            self._handle_wait_list(message.payload)
+        except HandlerError as e:
+            logger.error(e)
+
+    def process_events(self, *events: CloudMessage[TEvent]) -> None:
+        return self._process_messages(*events)

hexagonal/adapters/drivens/buses/base/infrastructure.py

@@ -0,0 +1,38 @@
+from hexagonal.application import InfrastructureGroup
+from hexagonal.ports.drivens import (
+    IBaseInfrastructure,
+    IBusInfrastructure,
+    ICommandBus,
+    IEventBus,
+    IQueryBus,
+    TManager,
+)
+
+
+class BaseBusInfrastructure(IBusInfrastructure[TManager], InfrastructureGroup):
+    def __init__(
+        self,
+        command_bus: ICommandBus[TManager],
+        event_bus: IEventBus[TManager],
+        query_bus: IQueryBus[TManager],
+        *args: IBaseInfrastructure,
+    ):
+        self._command_bus = command_bus
+        self._event_bus = event_bus
+        self._query_bus = query_bus
+        super().__init__(self._command_bus, self._event_bus, self._query_bus, *args)
+
+    @property
+    def command_bus(self):
+        self.verify()
+        return self._command_bus
+
+    @property
+    def event_bus(self):
+        self.verify()
+        return self._event_bus
+
+    @property
+    def query_bus(self):
+        self.verify()
+        return self._query_bus

hexagonal/adapters/drivens/buses/base/message_bus.py

@@ -0,0 +1,73 @@
+from abc import abstractmethod
+from typing import Any
+
+from hexagonal.application import Infrastructure
+from hexagonal.domain import CloudMessage
+from hexagonal.ports.drivens import (
+    IBaseMessageBus,
+    IInboxRepository,
+    IOutboxRepository,
+    TManager,
+)
+
+
+class MessageBus(IBaseMessageBus[TManager], Infrastructure):
+    def __init__(
+        self,
+        inbox_repository: IInboxRepository[TManager],
+        outbox_repository: IOutboxRepository[TManager],
+    ):
+        self._inbox_repository = inbox_repository
+        self._outbox_repository = outbox_repository
+        super().__init__()
+
+    @property
+    def inbox_repository(self) -> IInboxRepository[TManager]:
+        return self._inbox_repository
+
+    @property
+    def outbox_repository(self) -> IOutboxRepository[TManager]:
+        return self._outbox_repository
+
+    # publish
+    def publish_from_outbox(self, limit: int | None = None):
+        self.verify()
+        messages = self.outbox_repository.fetch_pending(limit=limit)
+        self._publish_messages(*messages)
+
+    def _publish_messages(self, *messages: CloudMessage[Any]) -> None:
+        for message in messages:
+            try:
+                self._publish_message(message)
+                self.outbox_repository.mark_as_published(message.message_id)
+            except Exception as e:
+                self.outbox_repository.mark_as_failed(message.message_id, error=str(e))
+
+    @abstractmethod
+    def _publish_message(self, message: CloudMessage[Any]) -> None: ...
+
+    # consume
+    def _process_messages(self, *messages: CloudMessage[Any]) -> None:
+        handlers: list[tuple[CloudMessage[Any], str]] = []
+        for msg in messages:
+            handlers.extend((msg, handler) for handler in self._get_handlers(msg))
+        for msg, handler in handlers:
+            self._process_message(msg, handler)
+
+    def _process_message(self, message: CloudMessage[Any], handler: str) -> None:
+        duplicated = self.inbox_repository.register_message(message, handler)
+        if not duplicated:
+            try:
+                self._handle_message(message, handler)
+                self.inbox_repository.mark_as_processed(message.message_id, handler)
+            except Exception as e:
+                self.inbox_repository.mark_as_failed(
+                    message.message_id, handler, error=str(e)
+                )
+                raise
+
+    @abstractmethod
+    def _get_handlers(self, message: CloudMessage[Any]) -> list[str]: ...
+
+    @abstractmethod
+    def _handle_message(self, message: CloudMessage[Any], handler: str) -> None: ...

hexagonal/adapters/drivens/buses/base/query.py

@@ -0,0 +1,82 @@
+from typing import Any, Literal, Mapping, Type, overload
+
+from eventsourcing.utils import get_topic
+
+from hexagonal.application import Infrastructure
+from hexagonal.domain import (
+    HandlerAlreadyRegistered,
+    HandlerNotRegistered,
+    Query,
+    QueryResult,
+    QueryResults,
+    TQuery,
+    TView,
+)
+from hexagonal.ports.drivens import IQueryBus, IQueryHandler, TManager
+
+
+class QueryBus(IQueryBus[TManager], Infrastructure):
+    handlers: dict[str, IQueryHandler[TManager, Any, Any]]
+
+    def initialize(self, env: Mapping[str, str]) -> None:
+        self.handlers = {}
+        super().initialize(env)
+
+    def _get_name(self, query_type: Type[Query[TView]]) -> str:
+        return get_topic(query_type)
+
+    def _get_handler(
+        self, query: Query[TView]
+    ) -> IQueryHandler[TManager, Query[TView], TView] | None:
+        name = self._get_name(query.__class__)
+        return self.handlers.get(name)
+
+    def register_handler(
+        self,
+        query_type: Type[TQuery],
+        handler: IQueryHandler[TManager, TQuery, TView],
+    ):
+        self.verify()
+        name = self._get_name(query_type)
+        if name in self.handlers:
+            raise HandlerAlreadyRegistered(f"Query: {name}")
+        self.handlers[name] = handler
+
+    def unregister_handler(self, query_type: Type[TQuery]):
+        self.verify()
+        name = self._get_name(query_type)
+        if name in self.handlers:
+            del self.handlers[name]
+        else:
+            raise HandlerNotRegistered(f"Query: {name}")
+
+    @overload
+    def get(self, query: Query[TView], *, one: Literal[True]) -> QueryResult[TView]: ...
+
+    @overload
+    def get(
+        self,
+        query: Query[TView],
+        *,
+        one: Literal[False] = False,
+    ) -> QueryResults[TView]: ...
+
+    def get(
+        self,
+        query: Query[TView],
+        *,
+        one: bool = False,
+    ) -> QueryResult[TView] | QueryResults[TView]:
+        self.verify()
+        name = self._get_name(query.__class__)
+        handler = self._get_handler(query)
+        if not handler:
+            raise HandlerNotRegistered(f"Query: {name}")
+        results = handler.get(query)
+        if not one:
+            return results
+        if len(results) == 0:
+            raise ValueError("No results found")
+        if len(results) > 1:
+            raise ValueError("More than one result found")
+        return QueryResult[TView](item=results.items[0])

hexagonal/adapters/drivens/buses/base/utils.py

@@ -0,0 +1 @@
+EVENT_BUS_RAISE_ERROR = "EVENT_BUS_RAISE_ERROR"

hexagonal/adapters/drivens/buses/inmemory/__init__.py

@@ -0,0 +1,12 @@
+from .command_bus import InMemoryCommandBus, InMemoryQueueCommandBus
+from .event_bus import InMemoryEventBus, InMemoryQueueEventBus
+from .infra import InMemoryBusInfrastructure, InMemoryQueueBusInfrastructure
+
+__all__ = [
+    "InMemoryEventBus",
+    "InMemoryCommandBus",
+    "InMemoryQueueCommandBus",
+    "InMemoryBusInfrastructure",
+    "InMemoryQueueBusInfrastructure",
+    "InMemoryQueueEventBus",
+]

hexagonal/adapters/drivens/buses/inmemory/command_bus.py

@@ -0,0 +1,70 @@
+# pyright: reportMissingParameterType=none, reportGeneralTypeIssues=none
+
+import logging
+import threading
+from queue import Empty, Queue
+from typing import Any, Mapping
+
+from hexagonal.adapters.drivens.buses.base import BaseCommandBus
+from hexagonal.domain import CloudMessage, TCommand
+from hexagonal.ports.drivens import TManager
+
+logger = logging.getLogger(__name__)
+
+
+class InMemoryCommandBus(BaseCommandBus[TManager]):
+    def _publish_message(self, message: CloudMessage[TCommand]) -> None:
+        return self._process_messages(message)
+
+    def consume(self, limit: int | None = None):
+        return  # No-op for non-queued bus
+
+
+class InMemoryQueueCommandBus(BaseCommandBus[TManager]):
+    def initialize(self, env: Mapping[str, str]) -> None:
+        self.queue: Queue[CloudMessage[Any]] = Queue()
+        self._stop = threading.Event()
+        self._worker = threading.Thread(target=self._worker_loop, daemon=True)
+
+        super().initialize(env)
+
+    def shutdown(self) -> None:
+        # Si tienes lifecycle, llama esto al apagar la app
+        self._stop.set()
+        self._worker.join(timeout=5)
+
+    def _publish_message(self, message: CloudMessage[TCommand]) -> None:
+        self.verify()
+        self.queue.put(
+            message
+        )  # bloquea si hubiera maxsize; puedes usar put_nowait si quieres
+        logger.debug(
+            "Enqueued command: %s | %s | %s | %s",
+            message.message_id,
+            message.causation_id,
+            message.correlation_id,
+            message.type,
+        )
+        # No llamamos consume() aquí. El worker ya está drenando.
+
+    def _worker_loop(self) -> None:
+        while not self._stop.is_set():
+            try:
+                message = self.queue.get(timeout=0.2)
+            except Empty:
+                continue
+
+            try:
+                logger.debug(
+                    "Processing command: %s | %s | %s | %s",
+                    message.message_id,
+                    message.causation_id,
+                    message.correlation_id,
+                    message.type,
+                )
+                self.dispatch(message)
+            finally:
+                self.queue.task_done()
+
+    def consume(self, limit: int | None = None):
+        self._worker.start()

hexagonal/adapters/drivens/buses/inmemory/event_bus.py

@@ -0,0 +1,69 @@
+# pyright: reportMissingParameterType=none, reportGeneralTypeIssues=none, reportUnknownMemberType=none
+
+import logging
+import threading
+from queue import Empty, Queue
+from typing import Mapping
+
+from hexagonal.adapters.drivens.buses.base import BaseEventBus
+from hexagonal.domain import CloudMessage, TEvent, TEvento
+from hexagonal.ports.drivens import TManager
+
+logger = logging.getLogger(__name__)
+
+
+class InMemoryEventBus(BaseEventBus[TManager]):
+    def _publish_message(self, message: CloudMessage[TEvento]) -> None:
+        super()._publish_message(message)
+        self._process_messages(message)
+
+    def publish(self, *events: CloudMessage[TEvent]) -> None:
+        return self._publish_messages(*events)
+
+    def consume(self, limit: int | None = None):
+        pass  # No-op for non-queued bus
+
+
+class InMemoryQueueEventBus(BaseEventBus[TManager]):
+    def initialize(self, env: Mapping[str, str]) -> None:
+        self.queue: Queue[CloudMessage[TEvento]] = Queue()  # o Queue(maxsize=...)
+        self._stop = threading.Event()
+        self._worker = threading.Thread(target=self._worker_loop, daemon=True)
+
+        super().initialize(env)
+
+    def shutdown(self) -> None:
+        # Llamar en el lifecycle de tu app
+        self._stop.set()
+        self._worker.join(timeout=5)
+
+    def publish(self, *events: CloudMessage[TEvent]) -> None:
+        return self._publish_messages(*events)
+
+    def _publish_message(self, message: CloudMessage[TEvento]) -> None:
+        super()._publish_message(message)
+        self.verify()
+        self.queue.put(message)
+        # No llamamos consume() aquí: el worker se encarga.
+
+    def _worker_loop(self) -> None:
+        while not self._stop.is_set():
+            try:
+                event = self.queue.get(timeout=0.2)
+            except Empty:
+                continue
+
+            try:
+                logger.debug(
+                    "Processing event: %s | %s | %s | %s",
+                    event.message_id,
+                    event.causation_id,
+                    event.correlation_id,
+                    event.type,
+                )
+                self._process_messages(event)
+            finally:
+                self.queue.task_done()
+
+    def consume(self, limit: int | None = None):
+        self._worker.start()

hexagonal/adapters/drivens/buses/inmemory/infra.py

@@ -0,0 +1,49 @@
+# pyright: reportMissingParameterType=none, reportGeneralTypeIssues=none
+
+from typing import Any
+
+from hexagonal.adapters.drivens.buses.base import BaseBusInfrastructure, QueryBus
+from hexagonal.ports.drivens import (
+    IInboxRepository,
+    IOutboxRepository,
+    TManager,
+)
+
+from .command_bus import InMemoryCommandBus, InMemoryQueueCommandBus
+from .event_bus import InMemoryEventBus, InMemoryQueueEventBus
+
+
+class InMemoryBusInfrastructure(BaseBusInfrastructure[TManager]):
+    def __init__(
+        self,
+        inbox: IInboxRepository[TManager],
+        outbox: IOutboxRepository[TManager],
+        *args: Any,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            InMemoryCommandBus(inbox, outbox),
+            InMemoryEventBus(inbox, outbox),
+            QueryBus[TManager](),
+            inbox,
+            outbox,
+            *args,
+            **kwargs,
+        )
+
+
+class InMemoryQueueBusInfrastructure(BaseBusInfrastructure[TManager]):
+    def __init__(
+        self,
+        inbox: IInboxRepository[TManager],
+        outbox: IOutboxRepository[TManager],
+        *args: Any,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            InMemoryQueueCommandBus(inbox, outbox),
+            InMemoryQueueEventBus(inbox, outbox),
+            QueryBus(),
+            inbox,
+            outbox,
+        )