jararaca 0.2.37a12__py3-none-any.whl → 0.3.1__py3-none-any.whl

jararaca/scheduler/scheduler.py

@@ -1,5 +1,7 @@
 import asyncio
+import inspect
 import logging
+import time
 from contextlib import asynccontextmanager
 from dataclasses import dataclass
 from datetime import UTC, datetime
@@ -11,6 +13,7 @@ from croniter import croniter
 from jararaca.core.uow import UnitOfWorkContextProvider
 from jararaca.di import Container
 from jararaca.lifecycle import AppLifecycle
+from jararaca.messagebus.decorators import ScheduleDispatchData
 from jararaca.microservice import Microservice, SchedulerAppContext
 from jararaca.scheduler.decorators import ScheduledAction
 
@@ -22,9 +25,6 @@ class SchedulerConfig:
     interval: int
 
 
-class SchedulerBackend: ...
-
-
 def extract_scheduled_actions(
     app: Microservice, container: Container
 ) -> list[tuple[Callable[..., Any], "ScheduledAction"]]:
@@ -52,12 +52,11 @@ class Scheduler:
     def __init__(
         self,
         app: Microservice,
-        backend: SchedulerBackend,
-        config: SchedulerConfig,
+        interval: int,
     ) -> None:
         self.app = app
-        self.backend = backend
-        self.config = config
+
+        self.interval = interval
         self.container = Container(self.app)
         self.uow_provider = UnitOfWorkContextProvider(app, self.container)
 
@@ -115,7 +114,15 @@ class Scheduler:
             ):
                 try:
                     async with ctx:
-                        await func()
+                        signature = inspect.signature(func)
+                        if len(signature.parameters) > 0:
+                            logging.warning(
+                                f"Scheduled action {func.__module__}.{func.__qualname__} has parameters, but no arguments were provided. Must be using scheduler-v2"
+                            )
+                            await func(ScheduleDispatchData(time.time()))
+                        else:
+                            await func()
+
                 except BaseException as e:
                     if action_specs.exception_handler:
                         action_specs.exception_handler(e)
@@ -143,7 +150,7 @@ class Scheduler:
 
                         await self.process_task(func, scheduled_action)
 
-                    await asyncio.sleep(self.config.interval)
+                    await asyncio.sleep(self.interval)
 
         with asyncio.Runner(loop_factory=uvloop.new_event_loop) as runner:
             runner.run(run_scheduled_actions())

jararaca/scheduler/scheduler_v2.py

@@ -0,0 +1,346 @@
+import asyncio
+import contextlib
+import logging
+import signal
+import time
+from abc import ABC, abstractmethod
+from contextlib import asynccontextmanager
+from datetime import UTC, datetime
+from types import FrameType
+from typing import Any, AsyncGenerator, Callable
+from urllib.parse import parse_qs
+
+import aio_pika
+import croniter
+import urllib3
+import urllib3.util
+import uvloop
+from aio_pika import connect_robust
+from aio_pika.abc import AbstractChannel, AbstractRobustConnection
+from aio_pika.pool import Pool
+
+from jararaca.broker_backend import MessageBrokerBackend
+from jararaca.broker_backend.mapper import get_message_broker_backend_from_url
+from jararaca.core.uow import UnitOfWorkContextProvider
+from jararaca.di import Container
+from jararaca.lifecycle import AppLifecycle
+from jararaca.microservice import Microservice
+from jararaca.scheduler.decorators import ScheduledAction
+from jararaca.scheduler.types import DelayedMessageData
+
+logger = logging.getLogger(__name__)
+
+SCHEDULED_ACTION_LIST = list[tuple[Callable[..., Any], "ScheduledAction"]]
+
+
+def extract_scheduled_actions(
+    app: Microservice, container: Container
+) -> SCHEDULED_ACTION_LIST:
+    scheduled_actions: SCHEDULED_ACTION_LIST = []
+    for controllers in app.controllers:
+
+        controller_instance: Any = container.get_by_type(controllers)
+
+        controller_scheduled_actions = ScheduledAction.get_type_scheduled_actions(
+            controller_instance
+        )
+        scheduled_actions.extend(controller_scheduled_actions)
+
+    return scheduled_actions
+
+
+# region Message Broker Dispatcher
+
+
+class MessageBrokerDispatcher(ABC):
+
+    @abstractmethod
+    async def dispatch_scheduled_action(
+        self,
+        action_id: str,
+        timestamp: int,
+    ) -> None:
+        """
+        Dispatch a message to the message broker.
+        This is used to send a message to the message broker
+        to trigger the scheduled action.
+        """
+        raise NotImplementedError("dispatch() is not implemented yet.")
+
+    @abstractmethod
+    async def dispatch_delayed_message(
+        self,
+        delayed_message: DelayedMessageData,
+    ) -> None:
+        """
+        Dispatch a delayed message to the message broker.
+        This is used to send a message to the message broker
+        to trigger the scheduled action.
+        """
+
+        raise NotImplementedError("dispatch_delayed_message() is not implemented yet.")
+
+    @abstractmethod
+    async def initialize(self, scheduled_actions: SCHEDULED_ACTION_LIST) -> None:
+        raise NotImplementedError("initialize() is not implemented yet.")
+
+    async def dispose(self) -> None:
+        pass
+
+
+class RabbitMQBrokerDispatcher(MessageBrokerDispatcher):
+
+    def __init__(self, url: str) -> None:
+        self.url = url
+
+        self.conn_pool: "Pool[AbstractRobustConnection]" = Pool(
+            self._create_connection,
+            max_size=10,
+        )
+
+        self.channel_pool: "Pool[AbstractChannel]" = Pool(
+            self._create_channel,
+            max_size=10,
+        )
+
+        splitted = urllib3.util.parse_url(url)
+
+        assert splitted.scheme in ["amqp", "amqps"], "Invalid URL scheme"
+
+        assert splitted.host, "Invalid URL host"
+
+        assert splitted.query, "Invalid URL query"
+
+        query_params: dict[str, list[str]] = parse_qs(splitted.query)
+
+        assert "exchange" in query_params, "Missing exchange parameter"
+
+        assert query_params["exchange"], "Empty exchange parameter"
+
+        self.exchange = str(query_params["exchange"][0])
+
+    async def _create_connection(self) -> AbstractRobustConnection:
+        """
+        Create a connection to the RabbitMQ server.
+        This is used to send messages to the RabbitMQ server.
+        """
+        connection = await connect_robust(self.url)
+        return connection
+
+    async def _create_channel(self) -> AbstractChannel:
+        """
+        Create a channel to the RabbitMQ server.
+        This is used to send messages to the RabbitMQ server.
+        """
+        async with self.conn_pool.acquire() as connection:
+            channel = await connection.channel()
+            return channel
+
+    async def dispatch_scheduled_action(self, action_id: str, timestamp: int) -> None:
+        """
+        Dispatch a message to the RabbitMQ server.
+        This is used to send a message to the RabbitMQ server
+        to trigger the scheduled action.
+        """
+
+        logger.info(f"Dispatching message to {action_id} at {timestamp}")
+        async with self.channel_pool.acquire() as channel:
+            exchange = await channel.get_exchange(self.exchange)
+
+            await exchange.publish(
+                aio_pika.Message(body=str(timestamp).encode()),
+                routing_key=action_id,
+            )
+            logger.info(f"Dispatched message to {action_id} at {timestamp}")
+
+    async def dispatch_delayed_message(
+        self, delayed_message: DelayedMessageData
+    ) -> None:
+        """
+        Dispatch a delayed message to the RabbitMQ server.
+        This is used to send a message to the RabbitMQ server
+        to trigger the scheduled action.
+        """
+        async with self.channel_pool.acquire() as channel:
+
+            exchange = await channel.get_exchange(self.exchange)
+            await exchange.publish(
+                aio_pika.Message(
+                    body=delayed_message.payload,
+                ),
+                routing_key=f"{delayed_message.message_topic}.",
+            )
+
+    async def initialize(self, scheduled_actions: SCHEDULED_ACTION_LIST) -> None:
+        """
+        Initialize the RabbitMQ server.
+        This is used to create the exchange and queues for the scheduled actions.
+        """
+
+        async with self.channel_pool.acquire() as channel:
+
+            await channel.set_qos(prefetch_count=1)
+
+            await channel.declare_exchange(
+                name=self.exchange,
+                type="topic",
+                durable=True,
+                auto_delete=False,
+            )
+
+            for func, _ in scheduled_actions:
+                queue = await channel.declare_queue(
+                    name=ScheduledAction.get_function_id(func),
+                    durable=True,
+                )
+
+                await queue.bind(
+                    exchange=self.exchange,
+                    routing_key=ScheduledAction.get_function_id(func),
+                )
+
+    async def dispose(self) -> None:
+        await self.channel_pool.close()
+        await self.conn_pool.close()
+
+
+def get_message_broker_dispatcher_from_url(url: str) -> MessageBrokerDispatcher:
+    """
+    Factory function to create a message broker instance from a URL.
+    Currently, only RabbitMQ is supported.
+    """
+    if url.startswith("amqp://") or url.startswith("amqps://"):
+        return RabbitMQBrokerDispatcher(url=url)
+    else:
+        raise ValueError(f"Unsupported message broker URL: {url}")
+
+
+# endregion
+
+
+class SchedulerV2:
+
+    def __init__(
+        self,
+        app: Microservice,
+        interval: int,
+        broker_url: str,
+        backend_url: str,
+    ) -> None:
+        self.app = app
+
+        self.broker: MessageBrokerDispatcher = get_message_broker_dispatcher_from_url(
+            broker_url
+        )
+        self.backend: MessageBrokerBackend = get_message_broker_backend_from_url(
+            backend_url
+        )
+
+        self.interval = interval
+        self.container = Container(self.app)
+        self.uow_provider = UnitOfWorkContextProvider(app, self.container)
+
+        self.shutdown_event = asyncio.Event()
+
+        self.lifecycle = AppLifecycle(app, self.container)
+
+    def run(self) -> None:
+
+        def on_signal_received(signal: int, frame_type: FrameType | None) -> None:
+            logger.info("Received shutdown signal")
+            self.shutdown_event.set()
+
+        signal.signal(signal.SIGINT, on_signal_received)
+
+        with asyncio.Runner(loop_factory=uvloop.new_event_loop) as runner:
+            runner.run(self.start_scheduler())
+
+    async def start_scheduler(self) -> None:
+        """
+        Declares the scheduled actions and starts the scheduler.
+        This is the main entry point for the scheduler.
+        """
+        async with self.lifecycle():
+
+            scheduled_actions = extract_scheduled_actions(self.app, self.container)
+
+            await self.broker.initialize(scheduled_actions)
+
+            await self.run_scheduled_actions(scheduled_actions)
+
+    async def run_scheduled_actions(
+        self, scheduled_actions: SCHEDULED_ACTION_LIST
+    ) -> None:
+
+        while not self.shutdown_event.is_set():
+            now = int(time.time())
+            for func, scheduled_action in scheduled_actions:
+                if self.shutdown_event.is_set():
+                    break
+
+                async with self.backend.lock():
+
+                    last_dispatch_time: int | None = (
+                        await self.backend.get_last_dispatch_time(
+                            ScheduledAction.get_function_id(func)
+                        )
+                    )
+
+                    if last_dispatch_time is not None:
+                        cron = croniter.croniter(
+                            scheduled_action.cron, last_dispatch_time
+                        )
+                        next_run: datetime = cron.get_next(datetime).replace(tzinfo=UTC)
+                        if next_run > datetime.now(UTC):
+                            logger.info(
+                                f"Skipping {func.__module__}.{func.__qualname__} until {next_run}"
+                            )
+                            continue
+
+                    if not scheduled_action.allow_overlap:
+                        if (
+                            await self.backend.get_in_execution_count(
+                                ScheduledAction.get_function_id(func)
+                            )
+                            > 0
+                        ):
+                            continue
+
+                    await self.broker.dispatch_scheduled_action(
+                        ScheduledAction.get_function_id(func),
+                        now,
+                    )
+
+                    await self.backend.set_last_dispatch_time(
+                        ScheduledAction.get_function_id(func), now
+                    )
+
+                    logger.info(
+                        f"Scheduled {func.__module__}.{func.__qualname__} at {now}"
+                    )
+
+            for (
+                delayed_message_data
+            ) in await self.backend.dequeue_next_delayed_messages(now):
+                await self.broker.dispatch_delayed_message(delayed_message_data)
+
+            with contextlib.suppress(asyncio.TimeoutError):
+                await asyncio.wait_for(self.shutdown_event.wait(), self.interval)
+
+            # await self.shutdown_event.wait(self.interval)
+
+        logger.info("Scheduler stopped")
+
+        await self.backend.dispose()
+        await self.broker.dispose()
+
+
+@asynccontextmanager
+async def none_context() -> AsyncGenerator[None, None]:
+    yield
+
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+)

jararaca/scheduler/types.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel
+
+
+class DelayedMessageData(BaseModel):
+    message_topic: str
+    dispatch_time: int
+    payload: bytes

jararaca/utils/rabbitmq_utils.py

@@ -0,0 +1,84 @@
+from aio_pika.abc import AbstractChannel, AbstractExchange, AbstractQueue
+
+
+class RabbitmqUtils:
+
+    DEAD_LETTER_EXCHANGE = "dlx"
+    DEAD_LETTER_QUEUE = "dlq"
+
+    @classmethod
+    async def declare_dl_exchange(cls, channel: AbstractChannel) -> AbstractExchange:
+        """
+        Declare a Dead Letter Exchange (DLX) for the given channel.
+        """
+        await channel.set_qos(prefetch_count=1)
+        return await channel.declare_exchange(
+            cls.DEAD_LETTER_EXCHANGE,
+            type="direct",
+            durable=True,
+            auto_delete=False,
+        )
+
+    @classmethod
+    async def declare_dl_queue(cls, channel: AbstractChannel) -> AbstractQueue:
+        """
+        Declare a Dead Letter Queue (DLQ) for the given queue.
+        """
+        await channel.set_qos(prefetch_count=1)
+        return await channel.declare_queue(
+            cls.DEAD_LETTER_QUEUE,
+            durable=True,
+            arguments={
+                "x-dead-letter-exchange": "",
+                "x-dead-letter-routing-key": cls.DEAD_LETTER_EXCHANGE,
+            },
+        )
+
+    @classmethod
+    async def delcare_dl_kit(
+        cls,
+        channel: AbstractChannel,
+    ) -> tuple[AbstractExchange, AbstractQueue]:
+        """
+        Declare a Dead Letter Exchange and Queue (DLX and DLQ) for the given channel.
+        """
+        dlx = await cls.declare_dl_exchange(channel)
+        dlq = await cls.declare_dl_queue(channel)
+        await dlq.bind(dlx, routing_key=cls.DEAD_LETTER_EXCHANGE)
+        return dlx, dlq
+
+    @classmethod
+    async def declare_main_exchange(
+        cls,
+        channel: AbstractChannel,
+        exchange_name: str,
+    ) -> AbstractExchange:
+        """
+        Declare a main exchange for the given channel.
+        """
+        await channel.set_qos(prefetch_count=1)
+        return await channel.declare_exchange(
+            exchange_name,
+            type="topic",
+            durable=True,
+            auto_delete=False,
+        )
+
+    @classmethod
+    async def declare_queue(
+        cls,
+        channel: AbstractChannel,
+        queue_name: str,
+    ) -> AbstractQueue:
+        """
+        Declare a queue with the given name and properties.
+        """
+        await channel.set_qos(prefetch_count=1)
+        return await channel.declare_queue(
+            queue_name,
+            durable=True,
+            arguments={
+                "x-dead-letter-exchange": cls.DEAD_LETTER_EXCHANGE,
+                "x-dead-letter-routing-key": cls.DEAD_LETTER_EXCHANGE,
+            },
+        )

{jararaca-0.2.37a12.dist-info → jararaca-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: jararaca
-Version: 0.2.37a12
+Version: 0.3.1
 Summary: A simple and fast API framework for Python
 Author: Lucas S
 Author-email: me@luscasleo.dev
@@ -12,6 +12,7 @@ Classifier: Programming Language :: Python :: 3.13
 Provides-Extra: docs
 Provides-Extra: http
 Provides-Extra: opentelemetry
+Provides-Extra: watch
 Requires-Dist: aio-pika (>=9.4.3,<10.0.0)
 Requires-Dist: croniter (>=3.0.3,<4.0.0)
 Requires-Dist: fastapi (>=0.113.0,<0.114.0)
@@ -27,6 +28,7 @@ Requires-Dist: types-croniter (>=3.0.3.20240731,<4.0.0.0)
 Requires-Dist: types-redis (>=4.6.0.20240903,<5.0.0.0)
 Requires-Dist: uvicorn (>=0.30.6,<0.31.0)
 Requires-Dist: uvloop (>=0.20.0,<0.21.0)
+Requires-Dist: watchdog (>=3.0.0,<4.0.0) ; extra == "watch"
 Requires-Dist: websockets (>=13.0.1,<14.0.0)
 Project-URL: Repository, https://github.com/LuscasLeo/jararaca
 Description-Content-Type: text/markdown

{jararaca-0.2.37a12.dist-info → jararaca-0.3.1.dist-info}/RECORD

@@ -1,6 +1,9 @@
-jararaca/__init__.py,sha256=VBrN25GHJ3gDG95CcJWe3dmGcA-X2agzOCIBbjzc1Iw,15312
+jararaca/__init__.py,sha256=4WO-Th3vY1_0SKdLyviZN2rftiX7R5yPVNPGJ9Mf5Y0,15633
 jararaca/__main__.py,sha256=-O3vsB5lHdqNFjUtoELDF81IYFtR-DSiiFMzRaiSsv4,67
-jararaca/cli.py,sha256=K6df8fqEc4Qj-yGz5hmO3pSgFWxcLP4iciOP4LHida4,7979
+jararaca/broker_backend/__init__.py,sha256=GzEIuHR1xzgCJD4FE3harNjoaYzxHMHoEL0_clUaC-k,3528
+jararaca/broker_backend/mapper.py,sha256=vTsi7sWpNvlga1PWPFg0rCJ5joJ0cdzykkIc2Tuvenc,696
+jararaca/broker_backend/redis_broker_backend.py,sha256=a7DHchy3NAiD71Ix8SwmQOUnniu7uup-Woa4ON_4J7I,5786
+jararaca/cli.py,sha256=oaLqJlb-GAbhYpQHzl-P8ajPdo-G_ddIuSu2SsZNDh8,10244
 jararaca/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jararaca/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jararaca/core/providers.py,sha256=wktH84FK7c1s2wNq-fudf1uMfi3CQBR0neU2czJ_L0U,434
@@ -8,15 +11,18 @@ jararaca/core/uow.py,sha256=WrA50VWzfJIyZHeUhSs8IOpSA4T-D8VV6YPLlFTF5V4,2026
 jararaca/di.py,sha256=h3IsXdYZjJj8PJfnEDn0ZAwdd4EBfh8jU-wWO8ko_t4,76
 jararaca/files/entity.py.mako,sha256=tjQ-1udAMvVqgRokhsrR4uy3P_OVnbk3XZ8X69ixWhE,3098
 jararaca/lifecycle.py,sha256=qKlzLQQioS8QkxNJ_FC_5WbmT77cNbc_S7OcQeOoHkI,1895
-jararaca/messagebus/__init__.py,sha256=Zdl74HcS9K0FW6XUt7bVvaHEyxL8pWsqqakeRENIn0w,54
+jararaca/messagebus/__init__.py,sha256=5jAqPqdcEMYBfQyfZDWPnplYdrfMyJLMcacf3qLyUhk,56
 jararaca/messagebus/bus_message_controller.py,sha256=Xd_qwnX5jUvgBTCarHR36fvtol9lPTsYp2IIGKyQQaE,1487
-jararaca/messagebus/decorators.py,sha256=GHlaXRuHtrz6R0HgcG2gJybpGYtdts9meDVSRPwN74I,4245
+jararaca/messagebus/consumers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jararaca/messagebus/decorators.py,sha256=y-w4dWbP9ZW3ZJ4mE9iIaxw01ZC5snEbOuBY5NC-Bn0,5626
 jararaca/messagebus/interceptors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jararaca/messagebus/interceptors/aiopika_publisher_interceptor.py,sha256=BPH5wOlj_CyHtJ7W4NWF2h0gYMwzOPNzFhGADk618N4,4373
-jararaca/messagebus/publisher.py,sha256=5ay9Znwybqt981OOykdWkFisSvGiTeTpPXDFLMnaiqg,1109
-jararaca/messagebus/types.py,sha256=iYLyLxWqOHkDadxyMqQPWy3itLNQfvD6oQe8jcq9nzo,887
-jararaca/messagebus/worker.py,sha256=_X2Ctj7bI9XjCMvQMy8jM3dEE3CGnqgrU_B3lTGfmmQ,13605
-jararaca/microservice.py,sha256=1TvDKVMMREH27Ly8eTEheMmSfro4_Az_JKM_NdDvrgc,6636
+jararaca/messagebus/interceptors/aiopika_publisher_interceptor.py,sha256=Aex87wopB34sMNzXBgi4KucVHjL2wYog3-IH75DAfDk,5387
+jararaca/messagebus/interceptors/publisher_interceptor.py,sha256=fQFFW9hH6ZU3UOyR7kMPrNp9wA71qEy5XlgrBQdBMS4,1230
+jararaca/messagebus/message.py,sha256=U6cyd2XknX8mtm0333slz5fanky2PFLWCmokAO56vvU,819
+jararaca/messagebus/publisher.py,sha256=K7WsOMVTyLmdms3ZKEshqrQc_DhNreiFK-HnmOT9Ce0,1965
+jararaca/messagebus/worker.py,sha256=SGd7Mng33ivcaAP7cwmF_2loQPuHIfTwkCZtCNJ5G-I,13523
+jararaca/messagebus/worker_v2.py,sha256=F7Hl92h5PezxNUY3_lfv9jNhboyQouuk6hXocPGeyXY,20341
+jararaca/microservice.py,sha256=C_Txqm3xSmdHIghJigKk6TOycL5eTJv9PF6XP7TA8j4,6638
 jararaca/observability/decorators.py,sha256=XffBinFXdiNkY6eo8_1nkr_GapM0RUGBg0aicBIelag,2220
 jararaca/observability/interceptor.py,sha256=GHkuGKFWftN7MDjvYeGFGEPnuJETNhtxRK6yuPrCrpU,1462
 jararaca/observability/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -49,15 +55,19 @@ jararaca/rpc/http/backends/otel.py,sha256=Uc6CjHSCZ5hvnK1fNFv3ota5xzUFnvIl1JOpG3
 jararaca/rpc/http/decorators.py,sha256=oUSzgMGI8w6SoKiz3GltDbd3BWAuyY60F23cdRRNeiw,11897
 jararaca/rpc/http/httpx.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jararaca/scheduler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jararaca/scheduler/decorators.py,sha256=V6VtLA44HPEbevEcEGiHDHM3HZvka1P5kpvIm9nCMkc,2268
-jararaca/scheduler/scheduler.py,sha256=r1_OPTOsL9WkxTLBaxLiq1csujUqepvPg-8I4m28amU,4845
+jararaca/scheduler/decorators.py,sha256=cRwnQHtlo9iC-2c30t7GGTEURFmdtDPkkVrr5cRVblM,3645
+jararaca/scheduler/scheduler.py,sha256=ll3ifOZ9QZcyCX1jfuNagHMVAbhRoE9VAl0ox3MWnwo,5295
+jararaca/scheduler/scheduler_v2.py,sha256=5-_O6EzG95y_3aIw5SA4W_ppbPIIszBrCYM7cFvXgBo,11166
+jararaca/scheduler/types.py,sha256=4HEQOmVIDp-BYLSzqmqSFIio1bd51WFmgFPIzPpVu04,135
 jararaca/tools/app_config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jararaca/tools/app_config/decorators.py,sha256=-ckkMZ1dswOmECdo1rFrZ15UAku--txaNXMp8fd1Ndk,941
 jararaca/tools/app_config/interceptor.py,sha256=nfFZiS80hrbnL7-XEYrwmp2rwaVYBqxvqu3Y-6o_ov4,2575
 jararaca/tools/metadata.py,sha256=7nlCDYgItNybentPSSCc2MLqN7IpBd0VyQzfjfQycVI,1402
 jararaca/tools/typescript/interface_parser.py,sha256=4SHt094P-QawMFHSyMCiujQf8Niw7xACIO1RHBM8-w4,29192
-jararaca-0.2.37a12.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-jararaca-0.2.37a12.dist-info/METADATA,sha256=W8aHUpqo5Q5iGBwX0BE4CS9MfEEMN97vM-YRuCJ2URM,4873
-jararaca-0.2.37a12.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-jararaca-0.2.37a12.dist-info/entry_points.txt,sha256=WIh3aIvz8LwUJZIDfs4EeH3VoFyCGEk7cWJurW38q0I,45
-jararaca-0.2.37a12.dist-info/RECORD,,
+jararaca/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jararaca/utils/rabbitmq_utils.py,sha256=zFqZE-j6TSWFOEPbkIaB2hy2sqsXup-5421jIiPLfXY,2543
+jararaca-0.3.1.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+jararaca-0.3.1.dist-info/METADATA,sha256=TRaKZQ_5vbE3OS_sTSYCpq7aYkDX19zFlebpkenHo9A,4951
+jararaca-0.3.1.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+jararaca-0.3.1.dist-info/entry_points.txt,sha256=WIh3aIvz8LwUJZIDfs4EeH3VoFyCGEk7cWJurW38q0I,45
+jararaca-0.3.1.dist-info/RECORD,,

jararaca/messagebus/types.py

@@ -1,30 +0,0 @@
-from typing import ClassVar, Generic, Literal, Protocol, TypeVar
-
-from pydantic import BaseModel
-
-from jararaca.messagebus.publisher import use_publisher
-
-
-class Message(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"
-
-    async def publish(self) -> None:
-        task_publisher = use_publisher()
-        await task_publisher.publish(self, self.MESSAGE_TOPIC)
-
-
-INHERITS_MESSAGE_CO = TypeVar("INHERITS_MESSAGE_CO", bound=Message, covariant=True)
-
-
-class MessageOf(Protocol, Generic[INHERITS_MESSAGE_CO]):
-
-    def payload(self) -> INHERITS_MESSAGE_CO: ...