python-hexagonal 0.1.2__tar.gz → 0.3.0__tar.gz

python_hexagonal-0.3.0/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.3
+Name: python-hexagonal
+Version: 0.3.0
+Summary: Framework to build hexagonal architecture applications in Python.
+Author: jose-matos-9281
+Author-email: jose-matos-9281 <58991817+jose-matos-9281@users.noreply.github.com>
+Requires-Dist: eventsourcing>=9.4.6
+Requires-Dist: orjson>=3.11.5
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: sqlalchemy>=2.0.45
+Requires-Dist: uuid6>=2025.0.1
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# python-hexagonal
+
+`python-hexagonal` is a library for building hexagonal applications in Python.
+The real usage story lives in `src/example` and the proof lives in
+`src/tests/use_cases`, so this documentation starts there instead of pretending a
+two-line snippet is enough.
+
+## Start here
+
+- Install the package: `pip install python-hexagonal`
+- Follow the example-backed guide: [`docs/getting-started/first-app.md`](docs/getting-started/first-app.md)
+- Understand the architecture roles:
+  [`docs/explanation/architecture-from-example.md`](docs/explanation/architecture-from-example.md)
+- Bootstrap the adapter-specific SQLAlchemy path:
+  [`docs/how-to/bootstrap-sqlalchemy-app.md`](docs/how-to/bootstrap-sqlalchemy-app.md)
+- Migrate existing apps to the scoped execution model:
+  [`docs/how-to/migrate-to-0.3.0-scoped-execution.md`](docs/how-to/migrate-to-0.3.0-scoped-execution.md)
+- Learn the canonical testing workflow:
+  [`docs/how-to/test-use-cases.md`](docs/how-to/test-use-cases.md)
+- Check the guardrails before copying imports:
+  [`docs/reference/supported-surface.md`](docs/reference/supported-surface.md)
+- Review the evidence map if you want to verify a claim against code or tests:
+  [`docs/reference/evidence-map.yaml`](docs/reference/evidence-map.yaml)
+
+## What you learn from the first path
+
+After the first-app guide you should understand:
+
+- where the domain model lives and why it stays isolated
+- how application APIs wrap command, query, and event buses
+- how ports describe the infrastructure your app needs
+- how entrypoints assemble an app from environment and infrastructure
+- how the use-case tests prove the workflow end to end
+
+## The blueprint we actually trust
+
+These files are the baseline for the supported adoption story:
+
+- `src/example/contacto/domain/contacto.py` - aggregate behavior, value-object
+  strategy, and query entry points
+- `src/example/contacto/application/app.py` - application composition through
+  `BusAppGroup`
+- `src/example/contacto/ports/drivens.py` - infrastructure contracts and
+  repository boundaries
+- `src/example/app/application/api.py` - top-level API wrapper consumers call
+- `src/example/app/entrypoints/main.py` - environment-driven bootstrap via
+  `EntrypointGroup`
+- `src/example/app/entrypoints/db/sqlalchemy.py` - SQLAlchemy-specific
+  infrastructure assembly
+- `src/tests/use_cases/base.py` - canonical test bootstrap with migrations,
+  entrypoint creation, and topic registration
+
+## Supported path vs internals
+
+The documented path is intentionally narrow.
+
+- Start from `hexagonal.domain`, `hexagonal.application`,
+  `hexagonal.ports.drivens`, `hexagonal.ports.drivers`, and
+  `hexagonal.entrypoints`
+- Reach for `hexagonal.integrations.sqlalchemy` when you need the reusable
+  SQLAlchemy repository and unit-of-work utilities
+- Treat scoped execution as the default mental model: shared datastore and
+  mapper, fresh write/read scope per operation
+- Treat `hexagonal.entrypoints.sqlalchemy` as adapter-specific convenience, not
+  the whole framework story
+- Do not treat `hexagonal.__init__` as the public integration surface; right now
+  it only exposes `hello()`
+- Do not cargo-cult example names like `exampleAPI`, `exampleEntrypoint`, or
+  `Exampletate`; copy the roles, not the labels
+- Do not build new code against `hexagonal.adapters.*`; that path is kept for
+  compatibility, while the supported SQLAlchemy extension surface now lives under
+  `hexagonal.integrations.sqlalchemy`
+
+## Companion skill
+
+This repo also ships an installable companion skill at
+`skills/python-hexagonal-usage/SKILL.md`.
+It is there to inspect a user repository, map it to the same architecture, and
+point people back to the written docs. It does NOT replace the docs and it does
+NOT get to invent new supported APIs.

python_hexagonal-0.3.0/README.md

@@ -0,0 +1,80 @@
+# python-hexagonal
+
+`python-hexagonal` is a library for building hexagonal applications in Python.
+The real usage story lives in `src/example` and the proof lives in
+`src/tests/use_cases`, so this documentation starts there instead of pretending a
+two-line snippet is enough.
+
+## Start here
+
+- Install the package: `pip install python-hexagonal`
+- Follow the example-backed guide: [`docs/getting-started/first-app.md`](docs/getting-started/first-app.md)
+- Understand the architecture roles:
+  [`docs/explanation/architecture-from-example.md`](docs/explanation/architecture-from-example.md)
+- Bootstrap the adapter-specific SQLAlchemy path:
+  [`docs/how-to/bootstrap-sqlalchemy-app.md`](docs/how-to/bootstrap-sqlalchemy-app.md)
+- Migrate existing apps to the scoped execution model:
+  [`docs/how-to/migrate-to-0.3.0-scoped-execution.md`](docs/how-to/migrate-to-0.3.0-scoped-execution.md)
+- Learn the canonical testing workflow:
+  [`docs/how-to/test-use-cases.md`](docs/how-to/test-use-cases.md)
+- Check the guardrails before copying imports:
+  [`docs/reference/supported-surface.md`](docs/reference/supported-surface.md)
+- Review the evidence map if you want to verify a claim against code or tests:
+  [`docs/reference/evidence-map.yaml`](docs/reference/evidence-map.yaml)
+
+## What you learn from the first path
+
+After the first-app guide you should understand:
+
+- where the domain model lives and why it stays isolated
+- how application APIs wrap command, query, and event buses
+- how ports describe the infrastructure your app needs
+- how entrypoints assemble an app from environment and infrastructure
+- how the use-case tests prove the workflow end to end
+
+## The blueprint we actually trust
+
+These files are the baseline for the supported adoption story:
+
+- `src/example/contacto/domain/contacto.py` - aggregate behavior, value-object
+  strategy, and query entry points
+- `src/example/contacto/application/app.py` - application composition through
+  `BusAppGroup`
+- `src/example/contacto/ports/drivens.py` - infrastructure contracts and
+  repository boundaries
+- `src/example/app/application/api.py` - top-level API wrapper consumers call
+- `src/example/app/entrypoints/main.py` - environment-driven bootstrap via
+  `EntrypointGroup`
+- `src/example/app/entrypoints/db/sqlalchemy.py` - SQLAlchemy-specific
+  infrastructure assembly
+- `src/tests/use_cases/base.py` - canonical test bootstrap with migrations,
+  entrypoint creation, and topic registration
+
+## Supported path vs internals
+
+The documented path is intentionally narrow.
+
+- Start from `hexagonal.domain`, `hexagonal.application`,
+  `hexagonal.ports.drivens`, `hexagonal.ports.drivers`, and
+  `hexagonal.entrypoints`
+- Reach for `hexagonal.integrations.sqlalchemy` when you need the reusable
+  SQLAlchemy repository and unit-of-work utilities
+- Treat scoped execution as the default mental model: shared datastore and
+  mapper, fresh write/read scope per operation
+- Treat `hexagonal.entrypoints.sqlalchemy` as adapter-specific convenience, not
+  the whole framework story
+- Do not treat `hexagonal.__init__` as the public integration surface; right now
+  it only exposes `hello()`
+- Do not cargo-cult example names like `exampleAPI`, `exampleEntrypoint`, or
+  `Exampletate`; copy the roles, not the labels
+- Do not build new code against `hexagonal.adapters.*`; that path is kept for
+  compatibility, while the supported SQLAlchemy extension surface now lives under
+  `hexagonal.integrations.sqlalchemy`
+
+## Companion skill
+
+This repo also ships an installable companion skill at
+`skills/python-hexagonal-usage/SKILL.md`.
+It is there to inspect a user repository, map it to the same architecture, and
+point people back to the written docs. It does NOT replace the docs and it does
+NOT get to invent new supported APIs.

{python_hexagonal-0.1.2 → python_hexagonal-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-hexagonal"
-version = "0.1.2"
+version = "0.3.0"
 description = "Framework to build hexagonal architecture applications in Python."
 readme = "README.md"
 authors = [
@@ -26,9 +26,27 @@ module-name = "hexagonal"
 select = ["I", "E", "F", "B"]
 fixable = ["I", "E", "F", "B"]
 
+[tool.mypy]
+mypy_path = ["src"]
+python_version = "3.12"
+strict = true
+namespace_packages = true
+explicit_package_bases = true
+show_error_codes = true
+
+[[tool.mypy.overrides]]
+module = ["alembic", "alembic.*"]
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = ["tests.*"]
+disable_error_code = ["attr-defined", "no-untyped-call", "no-untyped-def", "var-annotated"]
+
 [dependency-groups]
 dev = [
+    "alembic>=1.18.4",
     "pytest>=9.0.2",
+    "python-dotenv>=1.2.2",
 ]
 sqlalchemy = [
     "sqlalchemy>=2.0.45",

{python_hexagonal-0.1.2 → python_hexagonal-0.3.0}/src/hexagonal/adapters/drivens/buses/base/command_bus.py

@@ -4,7 +4,6 @@ from eventsourcing.utils import get_topic
 
 from hexagonal.domain import (
     CloudMessage,
-    Command,
     HandlerAlreadyRegistered,
     HandlerNotRegistered,
     TCommand,
@@ -36,14 +35,14 @@ class BaseCommandBus(ICommandBus[TManager], MessageBus[TManager]):
 
     def register_handler(
         self, command_type: Type[TCommand], handler: IMessageHandler[TCommand]
-    ):
+    ) -> None:
         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]):
+    def unregister_handler(self, command_type: Type[TCommand]) -> None:
         self.verify()
         name = self._get_name(command_type)
         if name in self._handlers:
@@ -52,18 +51,16 @@ class BaseCommandBus(ICommandBus[TManager], MessageBus[TManager]):
             raise HandlerNotRegistered(f"Command: {name}")
 
     def dispatch(
-        self, command: TCommand | CloudMessage[TCommand], *, to_outbox: bool = False
+        self,
+        command: 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)
+            self.save_to_outbox(command)
         else:
-            self.process_command(cmd)
+            self.process_command(command)
 
     def process_command(self, command: CloudMessage[TCommand]) -> None:
         self._process_messages(command)

{python_hexagonal-0.1.2 → python_hexagonal-0.3.0}/src/hexagonal/adapters/drivens/buses/base/event_bus.py

@@ -21,22 +21,36 @@ logger = logging.getLogger(__name__)
 class HandlerError(Exception):
     def __init__(
         self,
-        evento: CloudMessage[TEvento],
+        evento: CloudMessage[TEvento] | 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]
+    ) -> None:
+        handler_name = (
+            handler.__class__.__name__
             if isinstance(handler, IMessageHandler)
             else handler.__name__
-        }   
-    evento: {evento.type}
-    datos: {evento.model_dump_json(indent=2)}
+        )
+        event_name = (
+            evento.__class__.__name__
+            if not isinstance(evento, CloudMessage)
+            else evento.payload.__class__.__name__
+        )
+        event_topic = (
+            evento.TOPIC if not isinstance(evento, CloudMessage) else evento.type
+        )
+        event_dump = (
+            evento.model_dump_json(indent=2)
+            if not isinstance(evento, CloudMessage)
+            else evento.model_dump_json(indent=2)
+        )
+        super().__init__(f"""
+Error al Manejar Evento {event_name}
+    handler: {handler_name}
+    evento: {event_topic}
+    datos: {event_dump}
     error: {error}
     stacktrace: {error.__traceback__}
-        """)  # type: ignore  # noqa: E501
+        """)
 
 
 class BaseEventBus(IEventBus[TManager], MessageBus[TManager]):
@@ -52,6 +66,9 @@ class BaseEventBus(IEventBus[TManager], MessageBus[TManager]):
     def _get_key(self, obj: Type[TEvent] | IMessageHandler[TEvent]) -> str:
         if not isinstance(obj, IMessageHandler):
             return get_topic(obj)
+        handler_key = getattr(obj, "handler_key", None)
+        if isinstance(handler_key, str):
+            return handler_key
         try:
             return get_topic(obj.__class__)
         except TopicError as e:
@@ -59,7 +76,9 @@ class BaseEventBus(IEventBus[TManager], MessageBus[TManager]):
                 f"Handler: {obj.__class__}, error: {e}"
             ) from e
 
-    def subscribe(self, event_type: Type[TEvent], handler: IMessageHandler[TEvent]):
+    def subscribe(
+        self, event_type: Type[TEvent], handler: IMessageHandler[TEvent]
+    ) -> None:
         self.verify()
         key_event = self._get_key(event_type)
         handlers = self.handlers.get(key_event, {})
@@ -69,7 +88,9 @@ class BaseEventBus(IEventBus[TManager], MessageBus[TManager]):
         handlers[key_handler] = handler
         self.handlers[key_event] = handlers
 
-    def unsubscribe(self, event_type: Type[TEvent], *handlers: IMessageHandler[TEvent]):
+    def unsubscribe(
+        self, event_type: Type[TEvent], *handlers: IMessageHandler[TEvent]
+    ) -> None:
         self.verify()
         key_event = self._get_key(event_type)
         if not handlers:
@@ -88,7 +109,9 @@ class BaseEventBus(IEventBus[TManager], MessageBus[TManager]):
         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]):
+    def _wait_for(
+        self, event_type: Type[TEvent], handler: Callable[[TEvent], None]
+    ) -> None:
         name = self._get_key(event_type)
         if name not in self.wait_list:
             self.wait_list[name] = []
@@ -99,7 +122,7 @@ class BaseEventBus(IEventBus[TManager], MessageBus[TManager]):
             len(self.wait_list[name]),
         )
 
-    def _handle_wait_list(self, event: TEvento):
+    def _handle_wait_list(self, event: TEvento) -> None:
         event_type = type(event)
         key = self._get_key(event_type)
         logger.debug("    [DEBUG _handle_wait_list] Publishing event type=%s", key)
@@ -112,14 +135,17 @@ class BaseEventBus(IEventBus[TManager], MessageBus[TManager]):
             logger.debug("    [DEBUG _handle_wait_list] No handlers registered!")
         while wait_list:
             if self.raise_error:
-                handler = wait_list.pop()
-                handler(event)
+                immediate_handler = wait_list.pop()
+                immediate_handler(event)
             else:
+                queued_handler: Callable[[TEvento], None] | None = None
                 try:
-                    handler = wait_list.pop()
-                    handler(event)
+                    queued_handler = wait_list.pop()
+                    queued_handler(event)
                 except Exception as e:
-                    raise HandlerError(event, handler, e) from e  # type: ignore
+                    if queued_handler is None:
+                        raise
+                    raise HandlerError(event, queued_handler, e) from e
 
     @overload
     def wait_for_publish(
@@ -136,9 +162,10 @@ class BaseEventBus(IEventBus[TManager], MessageBus[TManager]):
     ) -> Callable[[Callable[[TEvent], None]], None] | None:
         self.verify()
         if handler:
-            return self._wait_for(event_type, handler)
+            self._wait_for(event_type, handler)
+            return None
 
-        def decorator(func: Callable[[TEvent], None]):
+        def decorator(func: Callable[[TEvent], None]) -> None:
             self._wait_for(event_type, func)
 
         return decorator
@@ -169,4 +196,4 @@ class BaseEventBus(IEventBus[TManager], MessageBus[TManager]):
             logger.error(e)
 
     def process_events(self, *events: CloudMessage[TEvent]) -> None:
-        return self._process_messages(*events)
+        self._process_messages(*events)

{python_hexagonal-0.1.2 → python_hexagonal-0.3.0}/src/hexagonal/adapters/drivens/buses/base/infrastructure.py

@@ -16,23 +16,23 @@ class BaseBusInfrastructure(IBusInfrastructure[TManager], InfrastructureGroup):
         event_bus: IEventBus[TManager],
         query_bus: IQueryBus[TManager],
         *args: IBaseInfrastructure,
-    ):
+    ) -> None:
         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):
+    def command_bus(self) -> ICommandBus[TManager]:
         self.verify()
         return self._command_bus
 
     @property
-    def event_bus(self):
+    def event_bus(self) -> IEventBus[TManager]:
         self.verify()
         return self._event_bus
 
     @property
-    def query_bus(self):
+    def query_bus(self) -> IQueryBus[TManager]:
         self.verify()
         return self._query_bus

{python_hexagonal-0.1.2 → python_hexagonal-0.3.0}/src/hexagonal/adapters/drivens/buses/base/message_bus.py

@@ -1,5 +1,5 @@
 from abc import abstractmethod
-from typing import Any
+from typing import Any, Callable
 
 from hexagonal.application import Infrastructure
 from hexagonal.domain import CloudMessage
@@ -9,6 +9,7 @@ from hexagonal.ports.drivens import (
     IOutboxRepository,
     TManager,
 )
+from hexagonal.ports.drivens.scoped import IWriteScopeRunner, TWriteScope
 
 
 class MessageBus(IBaseMessageBus[TManager], Infrastructure):
@@ -16,9 +17,13 @@ class MessageBus(IBaseMessageBus[TManager], Infrastructure):
         self,
         inbox_repository: IInboxRepository[TManager],
         outbox_repository: IOutboxRepository[TManager],
-    ):
+    ) -> None:
         self._inbox_repository = inbox_repository
         self._outbox_repository = outbox_repository
+        self._write_scope_runner: IWriteScopeRunner[Any] | None = None
+        self._outbox_repository_getter: (
+            Callable[[Any], IOutboxRepository[TManager]] | None
+        ) = None
         super().__init__()
 
     @property
@@ -29,8 +34,34 @@ class MessageBus(IBaseMessageBus[TManager], Infrastructure):
     def outbox_repository(self) -> IOutboxRepository[TManager]:
         return self._outbox_repository
 
+    def configure_scope_runtime(
+        self,
+        *,
+        write_scope_runner: IWriteScopeRunner[TWriteScope] | None = None,
+        outbox_repository_getter: Callable[[TWriteScope], IOutboxRepository[TManager]]
+        | None = None,
+    ) -> None:
+        self._write_scope_runner = write_scope_runner
+        self._outbox_repository_getter = outbox_repository_getter
+
+    def save_to_outbox(self, *messages: CloudMessage[Any]) -> None:
+        self.verify()
+        if self._write_scope_runner is None or self._outbox_repository_getter is None:
+            self.outbox_repository.save(*messages)
+            return
+        outbox_repository_getter = self._outbox_repository_getter
+
+        scope = self._write_scope_runner.current_write_scope
+        if scope is not None:
+            outbox_repository_getter(scope).save(*messages)
+            return
+
+        self._write_scope_runner.run_in_write_scope(
+            lambda write_scope: outbox_repository_getter(write_scope).save(*messages)
+        )
+
     # publish
-    def publish_from_outbox(self, limit: int | None = None):
+    def publish_from_outbox(self, limit: int | None = None) -> None:
         self.verify()
         messages = self.outbox_repository.fetch_pending(limit=limit)
         self._publish_messages(*messages)

{python_hexagonal-0.1.2 → python_hexagonal-0.3.0}/src/hexagonal/adapters/drivens/buses/base/query.py

@@ -7,12 +7,15 @@ from hexagonal.domain import (
     HandlerAlreadyRegistered,
     HandlerNotRegistered,
     Query,
+    QueryBase,
+    QueryOne,
     QueryResult,
     QueryResults,
     TQuery,
     TView,
 )
 from hexagonal.ports.drivens import IQueryBus, IQueryHandler, TManager
+from hexagonal.ports.drivens.scoped import IReadScopeRunner
 
 
 class QueryBus(IQueryBus[TManager], Infrastructure):
@@ -20,14 +23,20 @@ class QueryBus(IQueryBus[TManager], Infrastructure):
 
     def initialize(self, env: Mapping[str, str]) -> None:
         self.handlers = {}
+        self._read_scope_runner: IReadScopeRunner[Any] | None = None
         super().initialize(env)
 
-    def _get_name(self, query_type: Type[Query[TView]]) -> str:
+    def configure_read_scope_runtime(
+        self, read_scope_runner: IReadScopeRunner[Any] | None = None
+    ) -> None:
+        self._read_scope_runner = read_scope_runner
+
+    def _get_name(self, query_type: Type[QueryBase[TView]]) -> str:
         return get_topic(query_type)
 
     def _get_handler(
-        self, query: Query[TView]
-    ) -> IQueryHandler[TManager, Query[TView], TView] | None:
+        self, query: QueryBase[TView]
+    ) -> IQueryHandler[TManager, QueryBase[TView], TView] | None:
         name = self._get_name(query.__class__)
         return self.handlers.get(name)
 
@@ -35,14 +44,14 @@ class QueryBus(IQueryBus[TManager], Infrastructure):
         self,
         query_type: Type[TQuery],
         handler: IQueryHandler[TManager, TQuery, TView],
-    ):
+    ) -> None:
         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]):
+    def unregister_handler(self, query_type: Type[TQuery]) -> None:
         self.verify()
         name = self._get_name(query_type)
         if name in self.handlers:
@@ -50,6 +59,14 @@ class QueryBus(IQueryBus[TManager], Infrastructure):
         else:
             raise HandlerNotRegistered(f"Query: {name}")
 
+    @overload
+    def get(
+        self,
+        query: QueryOne[TView],
+        *,
+        one: bool = False,
+    ) -> QueryResult[TView]: ...
+
     @overload
     def get(self, query: Query[TView], *, one: Literal[True]) -> QueryResult[TView]: ...
 
@@ -63,7 +80,7 @@ class QueryBus(IQueryBus[TManager], Infrastructure):
 
     def get(
         self,
-        query: Query[TView],
+        query: Query[TView] | QueryOne[TView],
         *,
         one: bool = False,
     ) -> QueryResult[TView] | QueryResults[TView]:
@@ -73,7 +90,7 @@ class QueryBus(IQueryBus[TManager], Infrastructure):
         if not handler:
             raise HandlerNotRegistered(f"Query: {name}")
         results = handler.get(query)
-        if not one:
+        if not (one or isinstance(query, QueryOne)):
             return results
         if len(results) == 0:
             raise ValueError("No results found")

{python_hexagonal-0.1.2 → python_hexagonal-0.3.0}/src/hexagonal/adapters/drivens/buses/inmemory/command_bus.py

@@ -16,7 +16,7 @@ class InMemoryCommandBus(BaseCommandBus[TManager]):
     def _publish_message(self, message: CloudMessage[TCommand]) -> None:
         return self._process_messages(message)
 
-    def consume(self, limit: int | None = None):
+    def consume(self, limit: int | None = None) -> None:
         return  # No-op for non-queued bus
 
 
@@ -66,5 +66,5 @@ class InMemoryQueueCommandBus(BaseCommandBus[TManager]):
             finally:
                 self.queue.task_done()
 
-    def consume(self, limit: int | None = None):
+    def consume(self, limit: int | None = None) -> None:
         self._worker.start()

{python_hexagonal-0.1.2 → python_hexagonal-0.3.0}/src/hexagonal/adapters/drivens/buses/inmemory/event_bus.py

@@ -5,6 +5,8 @@ import threading
 from queue import Empty, Queue
 from typing import Mapping
 
+from eventsourcing.utils import strtobool
+
 from hexagonal.adapters.drivens.buses.base import BaseEventBus
 from hexagonal.domain import CloudMessage, TEvent, TEvento
 from hexagonal.ports.drivens import TManager
@@ -13,6 +15,9 @@ logger = logging.getLogger(__name__)
 
 
 class InMemoryEventBus(BaseEventBus[TManager]):
+    def shutdown(self) -> None:
+        return
+
     def _publish_message(self, message: CloudMessage[TEvento]) -> None:
         super()._publish_message(message)
         self._process_messages(message)
@@ -20,7 +25,7 @@ class InMemoryEventBus(BaseEventBus[TManager]):
     def publish(self, *events: CloudMessage[TEvent]) -> None:
         return self._publish_messages(*events)
 
-    def consume(self, limit: int | None = None):
+    def consume(self, limit: int | None = None) -> None:
         pass  # No-op for non-queued bus
 
 
@@ -28,7 +33,8 @@ 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)
+        daemon = strtobool(env.get("EVENT_BUS_WORKER_DAEMON", "true"))
+        self._worker = threading.Thread(target=self._worker_loop, daemon=daemon)
 
         super().initialize(env)
 
@@ -41,8 +47,8 @@ class InMemoryQueueEventBus(BaseEventBus[TManager]):
         return self._publish_messages(*events)
 
     def _publish_message(self, message: CloudMessage[TEvento]) -> None:
-        super()._publish_message(message)
         self.verify()
+        super()._publish_message(message)
         self.queue.put(message)
         # No llamamos consume() aquí: el worker se encarga.
 
@@ -65,5 +71,5 @@ class InMemoryQueueEventBus(BaseEventBus[TManager]):
             finally:
                 self.queue.task_done()
 
-    def consume(self, limit: int | None = None):
+    def consume(self, limit: int | None = None) -> None:
         self._worker.start()

{python_hexagonal-0.1.2 → python_hexagonal-0.3.0}/src/hexagonal/adapters/drivens/mappers.py

@@ -91,8 +91,8 @@ class MessageMapper(Mapper[UUID]):
             getattr(cls, f"upcast_v{from_version}_v{from_version + 1}")(event_state)
             from_version += 1
         if issubclass(cls, AggregateSnapshot):
-            return cls.model_validate(event_state)  # type: ignore[return-value]
-        domain_event = object.__new__(cls)
+            return cast(DomainEventProtocol[UUID], cls.model_validate(event_state))
+        domain_event = cast(DomainEventProtocol[UUID], object.__new__(cls))
         domain_event.__dict__.update(event_state)
         return domain_event
 
@@ -123,6 +123,8 @@ class MessageMapper(Mapper[UUID]):
 def default_orjson_value_serializer(obj: Any) -> Any:
     if isinstance(obj, (UUID, Decimal)):
         return str(obj)
+    if isinstance(obj, Inmutable):
+        return obj.model_dump(mode="json")
     raise TypeError