jararaca 0.2.37a12__py3-none-any.whl → 0.4.0a5__py3-none-any.whl

jararaca/messagebus/interceptors/publisher_interceptor.py

@@ -0,0 +1,42 @@
+# SPDX-FileCopyrightText: 2025 Lucas S
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from contextlib import asynccontextmanager
+from typing import AsyncContextManager, AsyncGenerator, Protocol
+
+from jararaca.broker_backend import MessageBrokerBackend
+from jararaca.messagebus.publisher import MessagePublisher, provide_message_publisher
+from jararaca.microservice import AppInterceptor, AppTransactionContext
+
+
+class MessageBusConnectionFactory(Protocol):
+
+    def provide_connection(self) -> AsyncContextManager[MessagePublisher]: ...
+
+
+class MessageBusPublisherInterceptor(AppInterceptor):
+
+    def __init__(
+        self,
+        connection_factory: MessageBusConnectionFactory,
+        connection_name: str = "default",
+        message_scheduler: MessageBrokerBackend | None = None,
+    ):
+        self.connection_factory = connection_factory
+        self.connection_name = connection_name
+        self.message_scheduler = message_scheduler
+
+    @asynccontextmanager
+    async def intercept(
+        self, app_context: AppTransactionContext
+    ) -> AsyncGenerator[None, None]:
+        if app_context.transaction_data.context_type == "websocket":
+            yield
+            return
+
+        async with self.connection_factory.provide_connection() as connection:
+            with provide_message_publisher(self.connection_name, connection):
+                yield
+
+                await connection.flush()

jararaca/messagebus/message.py

@@ -0,0 +1,31 @@
+# SPDX-FileCopyrightText: 2025 Lucas S
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from datetime import datetime, tzinfo
+from typing import Generic, Protocol, TypeVar
+
+from jararaca.messagebus.publisher import IMessage, use_publisher
+
+
+class Message(IMessage):
+
+    async def publish(self) -> None:
+        task_publisher = use_publisher()
+        await task_publisher.publish(self, self.MESSAGE_TOPIC)
+
+    async def delay(self, seconds: int) -> None:
+        task_publisher = use_publisher()
+        await task_publisher.delay(self, seconds)
+
+    async def schedule(self, when: datetime, tz: tzinfo) -> None:
+        task_publisher = use_publisher()
+        await task_publisher.schedule(self, when, tz)
+
+
+INHERITS_MESSAGE_CO = TypeVar("INHERITS_MESSAGE_CO", bound=Message, covariant=True)
+
+
+class MessageOf(Protocol, Generic[INHERITS_MESSAGE_CO]):
+
+    def payload(self) -> INHERITS_MESSAGE_CO: ...

jararaca/messagebus/publisher.py

@@ -1,13 +1,56 @@
+# 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
-from typing import Any, Generator, Protocol
+from datetime import datetime, tzinfo
+from typing import Any, ClassVar, Generator, Literal
 
 from pydantic import BaseModel
 
 
-class MessagePublisher(Protocol):
-    async def publish(self, message: BaseModel, topic: str) -> None:
-        raise NotImplementedError()
+class IMessage(BaseModel):
+    """
+    Base class for messages representing tasks.
+    A Task is a message that represents a unit of work to be done.
+    It is published to a TaskPublisher and consumed by a TaskHandler, wrapped in TaskData.
+    Note: A Task is not an Event.
+    """
+
+    MESSAGE_TOPIC: ClassVar[str] = "__unset__"
+
+    MESSAGE_TYPE: ClassVar[Literal["task", "event"]] = "task"
+
+    MESSAGE_CATEGORY: ClassVar[str] = "uncategorized"
+
+
+class MessagePublisher(ABC):
+    @abstractmethod
+    async def publish(self, message: IMessage, topic: str) -> None:
+        pass
+
+    @abstractmethod
+    async def delay(self, message: IMessage, seconds: int) -> None:
+        """
+        Delay the message for a given number of seconds.
+        """
+
+    @abstractmethod
+    async def schedule(
+        self, message: IMessage, when: datetime, timezone: tzinfo
+    ) -> None:
+        """
+        Schedule the message for a given datetime.
+        """
+
+    @abstractmethod
+    async def flush(self) -> None:
+        """
+        Publish all messages that have been delayed or scheduled.
+        This is typically called at the end of a request or task processing.
+        """
 
 
 message_publishers_ctx = ContextVar[dict[str, MessagePublisher]](