jararaca 0.3.11a16__py3-none-any.whl → 0.4.0a5__py3-none-any.whl

jararaca/messagebus/decorators.py

@@ -1,21 +1,22 @@
+# SPDX-FileCopyrightText: 2025 Lucas S
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+
 import inspect
 from dataclasses import dataclass
-from typing import Any, Awaitable, Callable, Generic, TypeVar, cast
+from typing import Any, Awaitable, Callable
 
-from jararaca.messagebus.message import INHERITS_MESSAGE_CO, Message, MessageOf
+from jararaca.messagebus.message import INHERITS_MESSAGE_CO
 from jararaca.reflect.controller_inspect import (
     ControllerMemberReflect,
     inspect_controller,
 )
+from jararaca.reflect.decorators import DECORATED_T, StackableDecorator
 from jararaca.scheduler.decorators import ScheduledAction, ScheduledActionData
 
-DECORATED_FUNC = TypeVar("DECORATED_FUNC", bound=Callable[..., Any])
-DECORATED_T = TypeVar("DECORATED_T", bound=Any)
-
 
-class MessageHandler(Generic[INHERITS_MESSAGE_CO]):
-
-    MESSAGE_INCOMING_ATTR = "__message_incoming__"
+class MessageHandler(StackableDecorator):
 
     def __init__(
         self,
@@ -23,50 +24,23 @@ class MessageHandler(Generic[INHERITS_MESSAGE_CO]):
         timeout: int | None = None,
         exception_handler: Callable[[BaseException], None] | None = None,
         nack_on_exception: bool = False,
-        auto_ack: bool = True,
+        auto_ack: bool = False,
         name: str | None = None,
     ) -> None:
         self.message_type = message
 
         self.timeout = timeout
         self.exception_handler = exception_handler
-        self.requeue_on_exception = nack_on_exception
+        self.nack_on_exception = nack_on_exception
         self.auto_ack = auto_ack
         self.name = name
 
-    def __call__(
-        self, func: Callable[[Any, MessageOf[INHERITS_MESSAGE_CO]], Awaitable[None]]
-    ) -> Callable[[Any, MessageOf[INHERITS_MESSAGE_CO]], Awaitable[None]]:
-
-        MessageHandler[Any].register(func, self)
-
-        return func
-
-    @staticmethod
-    def register(
-        func: Callable[[Any, MessageOf[INHERITS_MESSAGE_CO]], Awaitable[None]],
-        message_incoming: "MessageHandler[Any]",
-    ) -> None:
-
-        setattr(func, MessageHandler.MESSAGE_INCOMING_ATTR, message_incoming)
-
-    @staticmethod
-    def get_message_incoming(
-        func: Callable[[MessageOf[Any]], Awaitable[Any]],
-    ) -> "MessageHandler[Message] | None":
-        if not hasattr(func, MessageHandler.MESSAGE_INCOMING_ATTR):
-            return None
-
-        return cast(
-            MessageHandler[Message], getattr(func, MessageHandler.MESSAGE_INCOMING_ATTR)
-        )
-
 
 @dataclass(frozen=True)
 class MessageHandlerData:
     message_type: type[Any]
-    spec: MessageHandler[Message]
-    instance_callable: Callable[[MessageOf[Any]], Awaitable[None]]
+    spec: MessageHandler
+    instance_callable: Callable[..., Awaitable[None]]
     controller_member: ControllerMemberReflect
 
 
@@ -80,16 +54,22 @@ SCHEDULED_ACTION_DATA_SET = set[ScheduledActionData]
 MESSAGE_HANDLER_DATA_SET = set[MessageHandlerData]
 
 
-class MessageBusController:
+class MessageBusController(StackableDecorator):
 
-    MESSAGEBUS_ATTR = "__messagebus__"
-
-    def __init__(self) -> None:
+    def __init__(
+        self,
+        *,
+        inherit_class_decorators: bool = True,
+        inherit_methods_decorators: bool = True,
+    ) -> None:
         self.messagebus_factory: (
             Callable[[Any], tuple[MESSAGE_HANDLER_DATA_SET, SCHEDULED_ACTION_DATA_SET]]
             | None
         ) = None
 
+        self.inherit_class_decorators = inherit_class_decorators
+        self.inherit_methods_decorators = inherit_methods_decorators
+
     def get_messagebus_factory(
         self,
     ) -> Callable[
@@ -99,7 +79,7 @@ class MessageBusController:
             raise Exception("MessageBus factory is not set")
         return self.messagebus_factory
 
-    def __call__(self, cls_t: type[DECORATED_T]) -> type[DECORATED_T]:
+    def post_decorated(self, subject: DECORATED_T) -> None:
 
         def messagebus_factory(
             instance: DECORATED_T,
@@ -108,13 +88,17 @@ class MessageBusController:
 
             schedulers: SCHEDULED_ACTION_DATA_SET = set()
 
-            _, members = inspect_controller(cls_t)
+            assert inspect.isclass(
+                subject
+            ), "MessageBusController can only be applied to classes"
+
+            _, members = inspect_controller(subject)
 
             for name, member in members.items():
-                message_handler_decoration = MessageHandler.get_message_incoming(
+                message_handler_decoration = MessageHandler.get_last(
                     member.member_function
                 )
-                scheduled_action_decoration = ScheduledAction.get_scheduled_action(
+                scheduled_action_decoration = ScheduledAction.get_last(
                     member.member_function
                 )
 
@@ -123,7 +107,7 @@ class MessageBusController:
                     if not inspect.iscoroutinefunction(member.member_function):
                         raise Exception(
                             "Message incoming handler '%s' from '%s.%s' must be a coroutine function"
-                            % (name, cls_t.__module__, cls_t.__qualname__)
+                            % (name, subject.__module__, subject.__qualname__)
                         )
 
                     handlers.add(
@@ -138,7 +122,7 @@ class MessageBusController:
                     if not inspect.iscoroutinefunction(member.member_function):
                         raise Exception(
                             "Scheduled action handler '%s' from '%s.%s' must be a coroutine function"
-                            % (name, cls_t.__module__, cls_t.__qualname__)
+                            % (name, subject.__module__, subject.__qualname__)
                         )
                     instance_callable = getattr(instance, name)
 
@@ -153,21 +137,3 @@ class MessageBusController:
             return handlers, schedulers
 
         self.messagebus_factory = messagebus_factory
-
-        MessageBusController.register(cls_t, self)
-
-        return cls_t
-
-    @staticmethod
-    def register(func: type[DECORATED_T], messagebus: "MessageBusController") -> None:
-
-        setattr(func, MessageBusController.MESSAGEBUS_ATTR, messagebus)
-
-    @staticmethod
-    def get_messagebus(func: type[DECORATED_T]) -> "MessageBusController | None":
-        if not hasattr(func, MessageBusController.MESSAGEBUS_ATTR):
-            return None
-
-        return cast(
-            MessageBusController, getattr(func, MessageBusController.MESSAGEBUS_ATTR)
-        )

jararaca/messagebus/implicit_headers.py

@@ -0,0 +1,49 @@
+# SPDX-FileCopyrightText: 2025 Lucas S
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import datetime
+import decimal
+import typing
+from contextlib import contextmanager
+from contextvars import ContextVar
+from typing import Any, Dict, Generator
+
+FieldArray = list["FieldValue"]
+"""A data structure for holding an array of field values."""
+
+FieldTable = typing.Dict[str, "FieldValue"]
+FieldValue = (
+    bool
+    | bytes
+    | bytearray
+    | decimal.Decimal
+    | FieldArray
+    | FieldTable
+    | float
+    | int
+    | None
+    | str
+    | datetime.datetime
+)
+
+ImplicitHeaders = Dict[str, FieldValue]
+
+implicit_headers_ctx = ContextVar[ImplicitHeaders | None](
+    "implicit_headers_ctx", default=None
+)
+
+
+def use_implicit_headers() -> ImplicitHeaders | None:
+    return implicit_headers_ctx.get()
+
+
+@contextmanager
+def provide_implicit_headers(
+    implicit_headers: ImplicitHeaders,
+) -> Generator[None, Any, None]:
+    token = implicit_headers_ctx.set(implicit_headers)
+    try:
+        yield
+    finally:
+        implicit_headers_ctx.reset(token)

jararaca/messagebus/interceptors/__init__.py

@@ -0,0 +1,3 @@
+# SPDX-FileCopyrightText: 2025 Lucas S
+#
+# SPDX-License-Identifier: GPL-3.0-or-later

jararaca/messagebus/interceptors/aiopika_publisher_interceptor.py

@@ -1,3 +1,7 @@
+# SPDX-FileCopyrightText: 2025 Lucas S
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
 import logging
 from contextlib import asynccontextmanager
 from datetime import datetime, timedelta
@@ -9,6 +13,7 @@ from aio_pika.abc import AbstractConnection
 from pydantic import BaseModel
 
 from jararaca.broker_backend import MessageBrokerBackend
+from jararaca.messagebus import implicit_headers
 from jararaca.messagebus.interceptors.publisher_interceptor import (
     MessageBusConnectionFactory,
 )
@@ -41,9 +46,13 @@ class AIOPikaMessagePublisher(MessagePublisher):
         if not exchange:
             logging.warning(f"Exchange {self.exchange_name} not found")
             return
-        routing_key = f"{topic}."
+        routing_key = f"{topic}.#"
+
+        implicit_headers_data = implicit_headers.use_implicit_headers()
         await exchange.publish(
-            aio_pika.Message(body=message.model_dump_json().encode()),
+            aio_pika.Message(
+                body=message.model_dump_json().encode(), headers=implicit_headers_data
+            ),
             routing_key=routing_key,
         )
 
@@ -122,7 +131,7 @@ class AIOPikaConnectionFactory(MessageBusConnectionFactory):
         if connection_pool_config:
 
             async def get_connection() -> AbstractConnection:
-                return await aio_pika.connect_robust(self.url)
+                return await aio_pika.connect(self.url)
 
             self.connection_pool = aio_pika.pool.Pool[AbstractConnection](
                 get_connection,
@@ -142,7 +151,7 @@ class AIOPikaConnectionFactory(MessageBusConnectionFactory):
     @asynccontextmanager
     async def acquire_connection(self) -> AsyncGenerator[AbstractConnection, Any]:
         if not self.connection_pool:
-            async with await aio_pika.connect_robust(self.url) as connection:
+            async with await aio_pika.connect(self.url) as connection:
                 yield connection
         else:
 

jararaca/messagebus/interceptors/publisher_interceptor.py

@@ -1,3 +1,7 @@
+# SPDX-FileCopyrightText: 2025 Lucas S
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
 from contextlib import asynccontextmanager
 from typing import AsyncContextManager, AsyncGenerator, Protocol
 

jararaca/messagebus/message.py

@@ -1,3 +1,7 @@
+# SPDX-FileCopyrightText: 2025 Lucas S
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
 from datetime import datetime, tzinfo
 from typing import Generic, Protocol, TypeVar
 

jararaca/messagebus/publisher.py

@@ -1,3 +1,7 @@
+# SPDX-FileCopyrightText: 2025 Lucas S
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
 from abc import ABC, abstractmethod
 from contextlib import contextmanager, suppress
 from contextvars import ContextVar
@@ -19,6 +23,8 @@ class IMessage(BaseModel):
 
     MESSAGE_TYPE: ClassVar[Literal["task", "event"]] = "task"
 
+    MESSAGE_CATEGORY: ClassVar[str] = "uncategorized"
+
 
 class MessagePublisher(ABC):
     @abstractmethod