jararaca 0.3.11a7__tar.gz → 0.3.11a9__tar.gz

{jararaca-0.3.11a7 → jararaca-0.3.11a9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: jararaca
-Version: 0.3.11a7
+Version: 0.3.11a9
 Summary: A simple and fast API framework for Python
 Author: Lucas S
 Author-email: me@luscasleo.dev

{jararaca-0.3.11a7 → jararaca-0.3.11a9}/pyproject.toml

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

{jararaca-0.3.11a7 → jararaca-0.3.11a9}/src/jararaca/cli.py

@@ -8,7 +8,7 @@ import time
 from codecs import StreamWriter
 from pathlib import Path
 from typing import Any
-from urllib.parse import urlparse, urlunsplit
+from urllib.parse import parse_qs, urlparse, urlunsplit
 
 import aio_pika
 import click
@@ -17,9 +17,12 @@ from mako.template import Template
 
 from jararaca.messagebus import worker as worker_v1
 from jararaca.messagebus import worker_v2 as worker_v2_mod
+from jararaca.messagebus.decorators import MessageBusController, MessageHandler
 from jararaca.microservice import Microservice
 from jararaca.presentation.http_microservice import HttpMicroservice
 from jararaca.presentation.server import create_http_server
+from jararaca.reflect.controller_inspect import inspect_controller
+from jararaca.scheduler.decorators import ScheduledAction
 from jararaca.scheduler.scheduler import Scheduler
 from jararaca.scheduler.scheduler_v2 import SchedulerV2
 from jararaca.tools.typescript.interface_parser import (
@@ -70,75 +73,17 @@ def find_microservice_by_module_path(module_path: str) -> Microservice:
     return app
 
 
-async def declare_worker_infrastructure(
-    url: str,
-    exchange: str,
-    app: Microservice,
-    passive_declare: bool = False,
-) -> None:
-    """
-    Declare the infrastructure (exchanges and queues) for worker v1.
-    """
-    connection = await aio_pika.connect(url)
-    channel = await connection.channel()
-
-    # Declare main exchange
-    main_ex = await RabbitmqUtils.declare_main_exchange(
-        channel=channel,
-        exchange_name=exchange,
-        passive=passive_declare,
-    )
-
-    # Declare dead letter infrastructure
-    dlx, dlq = await RabbitmqUtils.declare_dl_kit(
-        channel=channel, passive=passive_declare
-    )
-
-    # Find all message handlers to declare their queues
-    from jararaca.di import Container
-    from jararaca.messagebus.decorators import MessageBusController
+# The v1 infrastructure declaration function has been removed as part of the CLI simplification
 
-    container = Container(app)
-
-    for instance_type in app.controllers:
-        controller = MessageBusController.get_messagebus(instance_type)
-        if controller is None:
-            continue
-
-        instance: Any = container.get_by_type(instance_type)
-        factory = controller.get_messagebus_factory()
-        handlers, _ = factory(instance)
-
-        for handler in handlers:
-            queue_name = f"{handler.message_type.MESSAGE_TOPIC}.{handler.instance_callable.__module__}.{handler.instance_callable.__qualname__}"
-            routing_key = f"{handler.message_type.MESSAGE_TOPIC}.#"
-
-            queue = await channel.declare_queue(
-                passive=passive_declare,
-                name=queue_name,
-                arguments={
-                    "x-dead-letter-exchange": dlx.name,
-                    "x-dead-letter-routing-key": dlq.name,
-                },
-                durable=True,
-            )
 
-            await queue.bind(exchange=main_ex, routing_key=routing_key)
-            click.echo(f"✓ Declared queue: {queue_name} (routing key: {routing_key})")
-
-    await channel.close()
-    await connection.close()
-
-
-async def declare_worker_v2_infrastructure(
+async def declare_worker_infrastructure(
     broker_url: str,
     app: Microservice,
-    passive_declare: bool = False,
+    force: bool = False,
 ) -> None:
     """
-    Declare the infrastructure (exchanges and queues) for worker v2.
+    Declare the infrastructure (exchanges and queues) for worker.
     """
-    from urllib.parse import parse_qs, urlparse
 
     parsed_url = urlparse(broker_url)
     if parsed_url.scheme not in ["amqp", "amqps"]:
@@ -157,132 +102,77 @@ async def declare_worker_v2_infrastructure(
     connection = await aio_pika.connect(broker_url)
     channel = await connection.channel()
 
-    # Declare main exchange
+    # Force delete infrastructure if requested
+    if force:
+        click.echo(f"→ Force deleting existing infrastructure for exchange: {exchange}")
+        await RabbitmqUtils.delete_exchange(channel, exchange)
+        await RabbitmqUtils.delete_exchange(channel, RabbitmqUtils.DEAD_LETTER_EXCHANGE)
+        await RabbitmqUtils.delete_queue(channel, RabbitmqUtils.DEAD_LETTER_QUEUE)
+
     await RabbitmqUtils.declare_main_exchange(
         channel=channel,
         exchange_name=exchange,
-        passive=passive_declare,
+        passive=not force,  # If force is True, we already deleted the exchange
     )
 
-    # Declare dead letter infrastructure
-    dlx = await RabbitmqUtils.declare_dl_exchange(
-        channel=channel, passive=passive_declare
-    )
-    dlq = await RabbitmqUtils.declare_dl_queue(channel=channel, passive=passive_declare)
+    dlx = await RabbitmqUtils.declare_dl_exchange(channel=channel, passive=not force)
+    dlq = await RabbitmqUtils.declare_dl_queue(channel=channel, passive=not force)
     await dlq.bind(dlx, routing_key=RabbitmqUtils.DEAD_LETTER_EXCHANGE)
 
     # Find all message handlers and scheduled actions
-    from jararaca.di import Container
-    from jararaca.messagebus.decorators import MessageBusController
-
-    container = Container(app)
 
     for instance_type in app.controllers:
-        controller = MessageBusController.get_messagebus(instance_type)
-        if controller is None:
+        controller_spec = MessageBusController.get_messagebus(instance_type)
+        if controller_spec is None:
             continue
 
-        instance: Any = container.get_by_type(instance_type)
-        factory = controller.get_messagebus_factory()
-        handlers, scheduled_actions = factory(instance)
+        _, members = inspect_controller(instance_type)
 
         # Declare queues for message handlers
-        for handler in handlers:
-            queue_name = f"{handler.message_type.MESSAGE_TOPIC}.{handler.instance_callable.__module__}.{handler.instance_callable.__qualname__}"
-            routing_key = f"{handler.message_type.MESSAGE_TOPIC}.#"
+        for name, member in members.items():
 
-            queue = await RabbitmqUtils.declare_queue(
-                channel=channel, queue_name=queue_name, passive=passive_declare
-            )
-            await queue.bind(exchange=exchange, routing_key=routing_key)
-            click.echo(
-                f"✓ Declared message handler queue: {queue_name} (routing key: {routing_key})"
+            message_handler = MessageHandler.get_message_incoming(
+                member.member_function
             )
+            if message_handler is not None:
 
-        # Declare queues for scheduled actions
-        for scheduled_action in scheduled_actions:
-            queue_name = f"{scheduled_action.callable.__module__}.{scheduled_action.callable.__qualname__}"
-            routing_key = queue_name
+                queue_name = f"{message_handler.message_type.MESSAGE_TOPIC}.{member.member_function.__module__}.{member.member_function.__qualname__}"
+                routing_key = f"{message_handler.message_type.MESSAGE_TOPIC}.#"
 
-            queue = await RabbitmqUtils.declare_queue(
-                channel=channel, queue_name=queue_name, passive=passive_declare
-            )
-            await queue.bind(exchange=exchange, routing_key=routing_key)
-            click.echo(
-                f"✓ Declared scheduled action queue: {queue_name} (routing key: {routing_key})"
-            )
+                # Force delete queue if requested
+                if force:
+                    await RabbitmqUtils.delete_queue(channel, queue_name)
 
-    await channel.close()
-    await connection.close()
-
-
-async def declare_scheduler_v2_infrastructure(
-    broker_url: str,
-    app: Microservice,
-    passive_declare: bool = False,
-) -> None:
-    """
-    Declare the infrastructure (exchanges and queues) for scheduler v2.
-    """
-    from urllib.parse import parse_qs, urlparse
-
-    from jararaca.scheduler.decorators import ScheduledAction
-
-    parsed_url = urlparse(broker_url)
-    if parsed_url.scheme not in ["amqp", "amqps"]:
-        raise ValueError(f"Unsupported broker URL scheme: {parsed_url.scheme}")
-
-    if not parsed_url.query:
-        raise ValueError("Query string must be set for AMQP URLs")
-
-    query_params = parse_qs(parsed_url.query)
-
-    if "exchange" not in query_params or not query_params["exchange"]:
-        raise ValueError("Exchange must be set in the query string")
-
-    exchange = query_params["exchange"][0]
-
-    connection = await aio_pika.connect(broker_url)
-    channel = await connection.channel()
+                # Declare queue
+                queue = await RabbitmqUtils.declare_queue(
+                    channel=channel, queue_name=queue_name, passive=not force
+                )
+                await queue.bind(exchange=exchange, routing_key=routing_key)
+                click.echo(
+                    f"✓ Declared message handler queue: {queue_name} (routing key: {routing_key})"
+                )
 
-    # Declare exchange for scheduler
-    await channel.declare_exchange(
-        name=exchange,
-        type="topic",
-        durable=True,
-        auto_delete=False,
-        passive=passive_declare,
-    )
+            scheduled_action = ScheduledAction.get_scheduled_action(
+                member.member_function
+            )
+            if scheduled_action is not None:
 
-    # Find all scheduled actions and declare their queues
-    from jararaca.di import Container
-    from jararaca.messagebus.decorators import MessageBusController
+                # Declare queues for scheduled actions
 
-    container = Container(app)
-    scheduled_actions: list[Any] = []
+                queue_name = f"{member.member_function.__module__}.{member.member_function.__qualname__}"
+                routing_key = queue_name
 
-    for instance_type in app.controllers:
-        controller = MessageBusController.get_messagebus(instance_type)
-        if controller is None:
-            continue
+                # Force delete queue if requested
+                if force:
+                    await RabbitmqUtils.delete_queue(channel, queue_name)
 
-        instance: Any = container.get_by_type(instance_type)
-        factory = controller.get_messagebus_factory()
-        _, actions = factory(instance)
-        scheduled_actions.extend(actions)
-
-    for scheduled_action in scheduled_actions:
-        queue_name = ScheduledAction.get_function_id(scheduled_action.callable)
-        queue = await channel.declare_queue(
-            name=queue_name,
-            durable=True,
-            passive=passive_declare,
-        )
-        await queue.bind(
-            exchange=exchange,
-            routing_key=queue_name,
-        )
-        click.echo(f"✓ Declared scheduler queue: {queue_name}")
+                queue = await RabbitmqUtils.declare_queue(
+                    channel=channel, queue_name=queue_name, passive=not force
+                )
+                await queue.bind(exchange=exchange, routing_key=routing_key)
+                click.echo(
+                    f"✓ Declared scheduled action queue: {queue_name} (routing key: {routing_key})"
+                )
 
     await channel.close()
     await connection.close()
@@ -327,6 +217,12 @@ def cli() -> None:
     "--passive-declare",
     is_flag=True,
     default=False,
+    help="[DEPRECATED] Use passive declarations (check if infrastructure exists without creating it)",
+)
+@click.option(
+    "--handlers",
+    type=str,
+    help="Comma-separated list of handler names to listen to. If not specified, all handlers will be used.",
 )
 def worker(
     app_path: str,
@@ -335,6 +231,7 @@ def worker(
     password: str | None,
     exchange: str,
     prefetch_count: int,
+    handlers: str | None,
     passive_declare: bool,
 ) -> None:
 
@@ -362,6 +259,11 @@ def worker(
 
     url = parsed_url.geturl()
 
+    # Parse handler names if provided
+    handler_names: set[str] | None = None
+    if handlers:
+        handler_names = {name.strip() for name in handlers.split(",") if name.strip()}
+
     config = worker_v1.AioPikaWorkerConfig(
         url=url,
         exchange=exchange,
@@ -369,7 +271,7 @@ def worker(
     )
 
     worker_v1.MessageBusWorker(app, config=config).start_sync(
-        passive_declare=passive_declare,
+        handler_names=handler_names,
     )
 
 
@@ -389,14 +291,27 @@ def worker(
     type=str,
     envvar="BACKEND_URL",
 )
-def worker_v2(app_path: str, broker_url: str, backend_url: str) -> None:
+@click.option(
+    "--handlers",
+    type=str,
+    help="Comma-separated list of handler names to listen to. If not specified, all handlers will be used.",
+)
+def worker_v2(
+    app_path: str, broker_url: str, backend_url: str, handlers: str | None
+) -> None:
 
     app = find_microservice_by_module_path(app_path)
 
+    # Parse handler names if provided
+    handler_names: set[str] | None = None
+    if handlers:
+        handler_names = {name.strip() for name in handlers.split(",") if name.strip()}
+
     worker_v2_mod.MessageBusWorker(
         app=app,
         broker_url=broker_url,
         backend_url=backend_url,
+        handler_names=handler_names,
     ).start_sync()
 
 
@@ -449,13 +364,26 @@ def server(app_path: str, host: str, port: int) -> None:
     type=int,
     default=1,
 )
+@click.option(
+    "--schedulers",
+    type=str,
+    help="Comma-separated list of scheduler names to run (only run schedulers with these names)",
+)
 def scheduler(
     app_path: str,
     interval: int,
+    schedulers: str | None = None,
 ) -> None:
     app = find_microservice_by_module_path(app_path)
 
-    Scheduler(app, interval=interval).run()
+    # Parse scheduler names if provided
+    scheduler_names: set[str] | None = None
+    if schedulers:
+        scheduler_names = {
+            name.strip() for name in schedulers.split(",") if name.strip()
+        }
+
+    Scheduler(app, interval=interval, scheduler_names=scheduler_names).run()
 
 
 @cli.command()
@@ -479,19 +407,34 @@ def scheduler(
     type=str,
     required=True,
 )
+@click.option(
+    "--schedulers",
+    type=str,
+    help="Comma-separated list of scheduler names to run (only run schedulers with these names)",
+)
 def scheduler_v2(
     interval: int,
     broker_url: str,
     backend_url: str,
     app_path: str,
+    schedulers: str | None = None,
 ) -> None:
 
     app = find_microservice_by_module_path(app_path)
+
+    # Parse scheduler names if provided
+    scheduler_names: set[str] | None = None
+    if schedulers:
+        scheduler_names = {
+            name.strip() for name in schedulers.split(",") if name.strip()
+        }
+
     scheduler = SchedulerV2(
         app=app,
         interval=interval,
         backend_url=backend_url,
         broker_url=broker_url,
+        scheduler_names=scheduler_names,
     )
     scheduler.run()
 
@@ -716,7 +659,7 @@ def gen_entity(entity_name: str, file_path: StreamWriter) -> None:
     )
 
 
-@cli.command("declare-queues-v1")
+@cli.command()
 @click.argument(
     "app_path",
     type=str,
@@ -740,98 +683,36 @@ def gen_entity(entity_name: str, file_path: StreamWriter) -> None:
     default=False,
     help="Use passive declarations (check if infrastructure exists without creating it)",
 )
-def declare_queues_v1(
-    app_path: str,
-    broker_url: str | None,
-    exchange: str,
-    passive_declare: bool,
-) -> None:
-    """
-    Declare RabbitMQ infrastructure (exchanges and queues) for worker v1.
-
-    This command pre-declares the necessary exchanges and queues that worker v1
-    needs, without starting the actual consumption processes.
-
-    Environment variables:
-    - BROKER_URL: Broker URL (e.g., amqp://guest:guest@localhost/)
-    - EXCHANGE: Exchange name (defaults to 'jararaca_ex')
-
-    Examples:
-
-    \b
-    # Declare worker v1 infrastructure
-    jararaca declare-queues-v1 myapp:app --broker-url amqp://guest:guest@localhost/
-
-    \b
-    # Use environment variables
-    export BROKER_URL="amqp://guest:guest@localhost/"
-    export EXCHANGE="my_exchange"
-    jararaca declare-queues-v1 myapp:app
-    """
-
-    app = find_microservice_by_module_path(app_path)
-
-    async def run_declarations() -> None:
-        if not broker_url:
-            click.echo(
-                "ERROR: --broker-url is required or set BROKER_URL environment variable",
-                err=True,
-            )
-            return
-
-        click.echo(
-            f"→ Declaring worker v1 infrastructure (URL: {broker_url}, Exchange: {exchange})"
-        )
-
-        try:
-            await declare_worker_infrastructure(
-                broker_url, exchange, app, passive_declare
-            )
-            click.echo("✓ Worker v1 infrastructure declared successfully!")
-        except Exception as e:
-            click.echo(
-                f"ERROR: Failed to declare worker v1 infrastructure: {e}", err=True
-            )
-            raise
-
-    asyncio.run(run_declarations())
-
-
-@cli.command("declare-queues-v2")
-@click.argument(
-    "app_path",
-    type=str,
-)
 @click.option(
-    "--broker-url",
+    "--handlers",
     type=str,
-    envvar="BROKER_URL",
-    help="Broker URL (e.g., amqp://guest:guest@localhost/) [env: BROKER_URL]",
+    help="Comma-separated list of handler names to declare queues for. If not specified, all handlers will be declared.",
 )
 @click.option(
-    "--exchange",
+    "--schedulers",
     type=str,
-    default="jararaca_ex",
-    envvar="EXCHANGE",
-    help="Exchange name [env: EXCHANGE]",
+    help="Comma-separated list of scheduler names to declare queues for. If not specified, all schedulers will be declared.",
 )
 @click.option(
-    "--passive-declare",
+    "--force",
     is_flag=True,
     default=False,
-    help="Use passive declarations (check if infrastructure exists without creating it)",
+    help="Force recreation by deleting existing exchanges and queues before declaring them",
 )
-def declare_queues_v2(
+def declare(
     app_path: str,
     broker_url: str | None,
     exchange: str,
     passive_declare: bool,
+    handlers: str | None,
+    schedulers: str | None,
+    force: bool,
 ) -> None:
     """
-    Declare RabbitMQ infrastructure (exchanges and queues) for worker v2 and scheduler v2.
+    Declare RabbitMQ infrastructure (exchanges and queues) for message handlers and schedulers.
 
-    This command pre-declares the necessary exchanges and queues that worker v2
-    and scheduler v2 need, without starting the actual consumption processes.
+    This command pre-declares the necessary exchanges and queues for message handlers and schedulers,
+    without starting the actual consumption processes.
 
     Environment variables:
     - BROKER_URL: Broker URL (e.g., amqp://guest:guest@localhost/)
@@ -840,14 +721,18 @@ def declare_queues_v2(
     Examples:
 
     \b
-    # Declare worker v2 and scheduler v2 infrastructure
-    jararaca declare-queues-v2 myapp:app --broker-url amqp://guest:guest@localhost/
+    # Declare infrastructure
+    jararaca declare myapp:app --broker-url amqp://guest:guest@localhost/
+
+    \b
+    # Force recreation of queues and exchanges
+    jararaca declare myapp:app --broker-url amqp://guest:guest@localhost/ --force
 
     \b
     # Use environment variables
     export BROKER_URL="amqp://guest:guest@localhost/"
     export EXCHANGE="my_exchange"
-    jararaca declare-queues-v2 myapp:app
+    jararaca declare myapp:app
     """
 
     app = find_microservice_by_module_path(app_path)
@@ -860,24 +745,36 @@ def declare_queues_v2(
             )
             return
 
-        # For v2, create the broker URL with exchange parameter
-        v2_broker_url = f"{broker_url}?exchange={exchange}"
+        # Parse handler names if provided
+        handler_names: set[str] | None = None
+        if handlers:
+            handler_names = {
+                name.strip() for name in handlers.split(",") if name.strip()
+            }
 
-        click.echo(f"→ Declaring worker v2 infrastructure (URL: {v2_broker_url})")
-        click.echo(f"→ Declaring scheduler v2 infrastructure (URL: {v2_broker_url})")
+        # Parse scheduler names if provided
+        scheduler_names: set[str] | None = None
+        if schedulers:
+            scheduler_names = {
+                name.strip() for name in schedulers.split(",") if name.strip()
+            }
 
         try:
-            await asyncio.gather(
-                declare_worker_v2_infrastructure(v2_broker_url, app, passive_declare),
-                declare_scheduler_v2_infrastructure(
-                    v2_broker_url, app, passive_declare
-                ),
+            # Create the broker URL with exchange parameter
+            broker_url_with_exchange = f"{broker_url}?exchange={exchange}"
+
+            click.echo(
+                f"→ Declaring worker infrastructure (URL: {broker_url_with_exchange})"
             )
             click.echo(
-                "✓ Worker v2 and scheduler v2 infrastructure declared successfully!"
+                f"→ Declaring scheduler infrastructure (URL: {broker_url_with_exchange})"
             )
+
+            await declare_worker_infrastructure(broker_url_with_exchange, app, force)
+
+            click.echo("✓ Worker and scheduler infrastructure declared successfully!")
         except Exception as e:
-            click.echo(f"ERROR: Failed to declare v2 infrastructure: {e}", err=True)
+            click.echo(f"ERROR: Failed to declare infrastructure: {e}", err=True)
             raise
 
     asyncio.run(run_declarations())

{jararaca-0.3.11a7 → jararaca-0.3.11a9}/src/jararaca/messagebus/decorators.py

@@ -24,6 +24,7 @@ class MessageHandler(Generic[INHERITS_MESSAGE_CO]):
         exception_handler: Callable[[BaseException], None] | None = None,
         nack_on_exception: bool = False,
         auto_ack: bool = True,
+        name: str | None = None,
     ) -> None:
         self.message_type = message
 
@@ -31,6 +32,7 @@ class MessageHandler(Generic[INHERITS_MESSAGE_CO]):
         self.exception_handler = exception_handler
         self.requeue_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]]
@@ -106,7 +108,7 @@ class MessageBusController:
 
             schedulers: SCHEDULED_ACTION_DATA_SET = set()
 
-            controller, members = inspect_controller(cls_t)
+            _, members = inspect_controller(cls_t)
 
             for name, member in members.items():
                 message_handler_decoration = MessageHandler.get_message_incoming(