jararaca 0.2.36__tar.gz → 0.2.37a0__tar.gz

{jararaca-0.2.36 → jararaca-0.2.37a0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jararaca
-Version: 0.2.36
+Version: 0.2.37a0
 Summary: A simple and fast API framework for Python
 Home-page: https://github.com/LuscasLeo/jararaca
 Author: Lucas S

{jararaca-0.2.36 → jararaca-0.2.37a0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "jararaca"
-version = "0.2.36"
+version = "0.2.37a0"
 description = "A simple and fast API framework for Python"
 authors = ["Lucas S <me@luscasleo.dev>"]
 readme = "README.md"

{jararaca-0.2.36 → jararaca-0.2.37a0}/src/jararaca/__init__.py

@@ -2,6 +2,14 @@ from importlib import import_module
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
+    from jararaca.messagebus.bus_message_controller import (
+        ack,
+        nack,
+        reject,
+        retry,
+        retry_later,
+        use_bus_message_controller,
+    )
     from jararaca.microservice import AppContext, AppInterceptor
     from jararaca.observability.interceptor import ObservabilityInterceptor
     from jararaca.observability.providers.otel import OtelObservabilityProvider
@@ -47,7 +55,7 @@ if TYPE_CHECKING:
     from .core.providers import ProviderSpec, Token
     from .di import Container
     from .messagebus.decorators import MessageBusController, MessageHandler
-    from .messagebus.interceptors.publisher_interceptor import (
+    from .messagebus.interceptors.aiopika_publisher_interceptor import (
         AIOPikaConnectionFactory,
         MessageBusPublisherInterceptor,
     )
@@ -104,6 +112,12 @@ if TYPE_CHECKING:
     from .tools.app_config.interceptor import AppConfigurationInterceptor
 
     __all__ = [
+        "use_bus_message_controller",
+        "ack",
+        "nack",
+        "reject",
+        "retry",
+        "retry_later",
         "RPCRequestNetworkError",
         "FILTER_SORT_ENTITY_ATTR_MAP",
         "FilterModel",
@@ -196,6 +210,16 @@ if TYPE_CHECKING:
 __SPEC_PARENT__: str = __spec__.parent  # type: ignore
 # A mapping of {<member name>: (package, <module name>)} defining dynamic imports
 _dynamic_imports: "dict[str, tuple[str, str, str | None]]" = {
+    "use_bus_message_controller": (
+        __SPEC_PARENT__,
+        "messagebus.bus_message_controller",
+        None,
+    ),
+    "ack": (__SPEC_PARENT__, "messagebus.bus_message_controller", None),
+    "nack": (__SPEC_PARENT__, "messagebus.bus_message_controller", None),
+    "reject": (__SPEC_PARENT__, "messagebus.bus_message_controller", None),
+    "retry": (__SPEC_PARENT__, "messagebus.bus_message_controller", None),
+    "retry_later": (__SPEC_PARENT__, "messagebus.bus_message_controller", None),
     "RPCRequestNetworkError": (__SPEC_PARENT__, "rpc.http.decorators", None),
     "FILTER_SORT_ENTITY_ATTR_MAP": (__SPEC_PARENT__, "persistence.sort_filter", None),
     "FilterModel": (__SPEC_PARENT__, "persistence.sort_filter", None),

jararaca-0.2.37a0/src/jararaca/messagebus/bus_message_controller.py

@@ -0,0 +1,67 @@
+from contextlib import contextmanager, suppress
+from contextvars import ContextVar
+from typing import Any, Generator, Protocol
+
+
+class BusMessageController(Protocol):
+
+    async def ack(self) -> None:
+        pass
+
+    async def nack(self) -> None:
+        pass
+
+    async def reject(self) -> None:
+        pass
+
+    async def retry(self) -> None:
+        pass
+
+    async def retry_later(self, delay: int) -> None:
+        pass
+
+
+bus_message_controller_ctxvar = ContextVar[BusMessageController](
+    "bus_message_controller"
+)
+
+
+@contextmanager
+def provide_bus_message_controller(
+    controller: BusMessageController,
+) -> Generator[None, Any, None]:
+    token = bus_message_controller_ctxvar.set(controller)
+    try:
+        yield
+    finally:
+        with suppress(LookupError):
+            bus_message_controller_ctxvar.reset(token)
+
+
+def use_bus_message_controller() -> BusMessageController:
+    return bus_message_controller_ctxvar.get()
+
+
+async def ack() -> None:
+    controller = use_bus_message_controller()
+    await controller.ack()
+
+
+async def nack() -> None:
+    controller = use_bus_message_controller()
+    await controller.nack()
+
+
+async def reject() -> None:
+    controller = use_bus_message_controller()
+    await controller.reject()
+
+
+async def retry() -> None:
+    controller = use_bus_message_controller()
+    await controller.retry()
+
+
+async def retry_later(delay: int) -> None:
+    controller = use_bus_message_controller()
+    await controller.retry_later(delay)

{jararaca-0.2.36 → jararaca-0.2.37a0}/src/jararaca/messagebus/worker.py

@@ -14,6 +14,10 @@ from pydantic import BaseModel
 from jararaca.core.uow import UnitOfWorkContextProvider
 from jararaca.di import Container
 from jararaca.lifecycle import AppLifecycle
+from jararaca.messagebus.bus_message_controller import (
+    BusMessageController,
+    provide_bus_message_controller,
+)
 from jararaca.messagebus.decorators import (
     MESSAGE_HANDLER_DATA_SET,
     MessageBusController,
@@ -170,7 +174,6 @@ class MessageHandlerCallback:
         async with self.consumer.lock:
             task = asyncio.create_task(self.handle_message(aio_pika_message))
             self.consumer.tasks.add(task)
-            # task.add_done_callback(self.tasks.discard)
             task.add_done_callback(self.handle_message_consume_done)
 
     def handle_message_consume_done(self, task: asyncio.Task[Any]) -> None:
@@ -273,7 +276,10 @@ class MessageHandlerCallback:
                 ctx = none_context()
             async with ctx:
                 try:
-                    await handler(builded_message)
+                    with provide_bus_message_controller(
+                        AioPikaMessageBusController(aio_pika_message)
+                    ):
+                        await handler(builded_message)
                     if not incoming_message_spec.auto_ack:
                         await aio_pika_message.ack()
                 except BaseException as base_exc:
@@ -374,3 +380,23 @@ class MessageBusWorker:
                 signal.SIGINT, on_shutdown, runner.get_loop()
             )
             runner.run(self.start_async())
+
+
+class AioPikaMessageBusController(BusMessageController):
+    def __init__(self, aio_pika_message: aio_pika.abc.AbstractIncomingMessage):
+        self.aio_pika_message = aio_pika_message
+
+    async def ack(self) -> None:
+        await self.aio_pika_message.ack()
+
+    async def nack(self) -> None:
+        await self.aio_pika_message.nack()
+
+    async def reject(self) -> None:
+        await self.aio_pika_message.reject()
+
+    async def retry(self) -> None:
+        await self.aio_pika_message.reject(requeue=True)
+
+    async def retry_later(self, delay: int) -> None:
+        raise NotImplementedError("Not implemented")