jararaca 0.3.11a2__py3-none-any.whl → 0.3.11a4__py3-none-any.whl

jararaca/__init__.py

@@ -73,7 +73,11 @@ if TYPE_CHECKING:
     from .persistence.interceptors.aiosqa_interceptor import (
         AIOSQAConfig,
         AIOSqlAlchemySessionInterceptor,
+        providing_new_session,
+        providing_session,
+        providing_transaction,
         use_session,
+        use_transaction,
     )
     from .persistence.utilities import (
         CriteriaBasedAttributeQueryInjector,
@@ -191,6 +195,10 @@ if TYPE_CHECKING:
         "Container",
         "WebSocketInterceptor",
         "use_session",
+        "use_transaction",
+        "providing_session",
+        "providing_transaction",
+        "providing_new_session",
         "Post",
         "Get",
         "Patch",
@@ -335,6 +343,26 @@ _dynamic_imports: "dict[str, tuple[str, str, str | None]]" = {
         "persistence.interceptors.aiosqa_interceptor",
         None,
     ),
+    "use_transaction": (
+        __SPEC_PARENT__,
+        "persistence.interceptors.aiosqa_interceptor",
+        None,
+    ),
+    "providing_session": (
+        __SPEC_PARENT__,
+        "persistence.interceptors.aiosqa_interceptor",
+        None,
+    ),
+    "providing_new_session": (
+        __SPEC_PARENT__,
+        "persistence.interceptors.aiosqa_interceptor",
+        None,
+    ),
+    "providing_transaction": (
+        __SPEC_PARENT__,
+        "persistence.interceptors.aiosqa_interceptor",
+        None,
+    ),
     "Post": (__SPEC_PARENT__, "presentation.decorators", None),
     "Get": (__SPEC_PARENT__, "presentation.decorators", None),
     "Patch": (__SPEC_PARENT__, "presentation.decorators", None),

jararaca/cli.py

@@ -1,3 +1,4 @@
+import asyncio
 import importlib
 import importlib.resources
 import multiprocessing
@@ -9,6 +10,7 @@ from pathlib import Path
 from typing import Any
 from urllib.parse import urlparse, urlunsplit
 
+import aio_pika
 import click
 import uvicorn
 from mako.template import Template
@@ -23,6 +25,7 @@ from jararaca.scheduler.scheduler_v2 import SchedulerV2
 from jararaca.tools.typescript.interface_parser import (
     write_microservice_to_typescript_interface,
 )
+from jararaca.utils.rabbitmq_utils import RabbitmqUtils
 
 LIBRARY_FILES_PATH = importlib.resources.files("jararaca.files")
 ENTITY_TEMPLATE_PATH = LIBRARY_FILES_PATH / "entity.py.mako"
@@ -67,6 +70,230 @@ 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()
+
+    await channel.set_qos(prefetch_count=1)
+
+    # 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
+
+    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.callable.__module__}.{handler.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(
+    broker_url: str,
+    app: Microservice,
+    passive_declare: bool = False,
+) -> None:
+    """
+    Declare the infrastructure (exchanges and queues) for worker v2.
+    """
+    from urllib.parse import parse_qs, urlparse
+
+    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()
+
+    await channel.set_qos(prefetch_count=1)
+
+    # Declare main exchange
+    await RabbitmqUtils.declare_main_exchange(
+        channel=channel,
+        exchange_name=exchange,
+        passive=passive_declare,
+    )
+
+    # 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)
+    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:
+            continue
+
+        instance: Any = container.get_by_type(instance_type)
+        factory = controller.get_messagebus_factory()
+        handlers, scheduled_actions = factory(instance)
+
+        # Declare queues for message handlers
+        for handler in handlers:
+            queue_name = f"{handler.message_type.MESSAGE_TOPIC}.{handler.callable.__module__}.{handler.callable.__qualname__}"
+            routing_key = f"{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 message handler queue: {queue_name} (routing key: {routing_key})"
+            )
+
+        # 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 = 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})"
+            )
+
+    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()
+
+    await channel.set_qos(prefetch_count=1)
+
+    # Declare exchange for scheduler
+    await channel.declare_exchange(
+        name=exchange,
+        type="topic",
+        durable=True,
+        auto_delete=False,
+        passive=passive_declare,
+    )
+
+    # Find all scheduled actions and declare their queues
+    from jararaca.di import Container
+    from jararaca.messagebus.decorators import MessageBusController
+
+    container = Container(app)
+    scheduled_actions: list[Any] = []
+
+    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()
+        _, 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}")
+
+    await channel.close()
+    await connection.close()
+
+
 @click.group()
 def cli() -> None:
     pass
@@ -493,3 +720,170 @@ def gen_entity(entity_name: str, file_path: StreamWriter) -> None:
             entityNameKebabCase=entity_kebab_case,
         )
     )
+
+
+@cli.command("declare-queues-v1")
+@click.argument(
+    "app_path",
+    type=str,
+)
+@click.option(
+    "--broker-url",
+    type=str,
+    envvar="BROKER_URL",
+    help="Broker URL (e.g., amqp://guest:guest@localhost/) [env: BROKER_URL]",
+)
+@click.option(
+    "--exchange",
+    type=str,
+    default="jararaca_ex",
+    envvar="EXCHANGE",
+    help="Exchange name [env: EXCHANGE]",
+)
+@click.option(
+    "--passive-declare",
+    is_flag=True,
+    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",
+    type=str,
+    envvar="BROKER_URL",
+    help="Broker URL (e.g., amqp://guest:guest@localhost/) [env: BROKER_URL]",
+)
+@click.option(
+    "--exchange",
+    type=str,
+    default="jararaca_ex",
+    envvar="EXCHANGE",
+    help="Exchange name [env: EXCHANGE]",
+)
+@click.option(
+    "--passive-declare",
+    is_flag=True,
+    default=False,
+    help="Use passive declarations (check if infrastructure exists without creating it)",
+)
+def declare_queues_v2(
+    app_path: str,
+    broker_url: str | None,
+    exchange: str,
+    passive_declare: bool,
+) -> None:
+    """
+    Declare RabbitMQ infrastructure (exchanges and queues) for worker v2 and scheduler v2.
+
+    This command pre-declares the necessary exchanges and queues that worker v2
+    and scheduler v2 need, 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 v2 and scheduler v2 infrastructure
+    jararaca declare-queues-v2 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-v2 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
+
+        # For v2, create the broker URL with exchange parameter
+        v2_broker_url = f"{broker_url}?exchange={exchange}"
+
+        click.echo(f"→ Declaring worker v2 infrastructure (URL: {v2_broker_url})")
+        click.echo(f"→ Declaring scheduler v2 infrastructure (URL: {v2_broker_url})")
+
+        try:
+            await asyncio.gather(
+                declare_worker_v2_infrastructure(v2_broker_url, app, passive_declare),
+                declare_scheduler_v2_infrastructure(
+                    v2_broker_url, app, passive_declare
+                ),
+            )
+            click.echo(
+                "✓ Worker v2 and scheduler v2 infrastructure declared successfully!"
+            )
+        except Exception as e:
+            click.echo(f"ERROR: Failed to declare v2 infrastructure: {e}", err=True)
+            raise
+
+    asyncio.run(run_declarations())

jararaca/persistence/base.py

@@ -1,6 +1,7 @@
 from typing import Any, Self, Type, TypeVar
 
 from pydantic import BaseModel
+from sqlalchemy.ext.asyncio import AsyncAttrs
 from sqlalchemy.orm import DeclarativeBase
 
 IDENTIFIABLE_SCHEMA_T = TypeVar("IDENTIFIABLE_SCHEMA_T")
@@ -20,7 +21,7 @@ def recursive_get_dict(obj: Any) -> Any:
         return obj
 
 
-class BaseEntity(DeclarativeBase):
+class BaseEntity(AsyncAttrs, DeclarativeBase):
 
     @classmethod
     def from_basemodel(cls, mutation: T_BASEMODEL) -> "Self":

jararaca/persistence/interceptors/aiosqa_interceptor.py

@@ -3,21 +3,47 @@ from contextvars import ContextVar
 from dataclasses import dataclass
 from typing import Any, AsyncGenerator, Generator
 
-from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+from sqlalchemy.ext.asyncio import (
+    AsyncSession,
+    AsyncSessionTransaction,
+    async_sessionmaker,
+    create_async_engine,
+)
 from sqlalchemy.ext.asyncio.engine import AsyncEngine
 
 from jararaca.microservice import AppContext, AppInterceptor
 
-ctx_session_map = ContextVar[dict[str, AsyncSession]]("ctx_session_map", default={})
+ctx_default_connection_name: ContextVar[str] = ContextVar("ctx_default_connection_name")
+
+
+def ensure_name(name: str | None) -> str:
+    if name is None:
+        return ctx_default_connection_name.get()
+    return name
+
+
+@dataclass
+class PersistenceCtx:
+    session: AsyncSession
+    tx: AsyncSessionTransaction
+
+
+ctx_session_map = ContextVar[dict[str, PersistenceCtx]]("ctx_session_map", default={})
 
 
 @contextmanager
-def provide_session(
-    connection_name: str, session: AsyncSession
+def providing_session(
+    session: AsyncSession,
+    tx: AsyncSessionTransaction,
+    connection_name: str | None = None,
 ) -> Generator[None, Any, None]:
+
+    connection_name = ensure_name(connection_name)
     current_map = ctx_session_map.get({})
 
-    token = ctx_session_map.set({**current_map, connection_name: session})
+    token = ctx_session_map.set(
+        {**current_map, connection_name: PersistenceCtx(session, tx)}
+    )
 
     try:
         yield
@@ -26,18 +52,60 @@ def provide_session(
             ctx_session_map.reset(token)
 
 
-def use_session(connection_name: str = "default") -> AsyncSession:
+@asynccontextmanager
+async def providing_new_session(
+    connection_name: str | None = None,
+) -> AsyncGenerator[AsyncSession, None]:
+
+    current_session = use_session(connection_name)
+
+    async with AsyncSession(
+        current_session.bind,
+    ) as new_session, new_session.begin() as new_tx:
+        with providing_session(new_session, new_tx, connection_name):
+            yield new_session
+
+
+def use_session(connection_name: str | None = None) -> AsyncSession:
+    connection_name = ensure_name(connection_name)
     current_map = ctx_session_map.get({})
     if connection_name not in current_map:
         raise ValueError(f"Session not found for connection {connection_name}")
 
-    return current_map[connection_name]
+    return current_map[connection_name].session
+
+
+@contextmanager
+def providing_transaction(
+    tx: AsyncSessionTransaction,
+    connection_name: str | None = None,
+) -> Generator[None, Any, None]:
+    connection_name = ensure_name(connection_name)
+
+    current_map = ctx_session_map.get({})
+
+    if connection_name not in current_map:
+        raise ValueError(f"No session found for connection {connection_name}")
+
+    with providing_session(current_map[connection_name].session, tx, connection_name):
+        yield
+
+
+def use_transaction(connection_name: str | None = None) -> AsyncSessionTransaction:
+    current_map = ctx_session_map.get({})
+    if connection_name not in current_map:
+        raise ValueError(f"Transaction not found for connection {connection_name}")
+
+    return current_map[connection_name].tx
 
 
-@dataclass
 class AIOSQAConfig:
-    connection_name: str
     url: str | AsyncEngine
+    connection_name: str
+
+    def __init__(self, url: str | AsyncEngine, connection_name: str = "default"):
+        self.url = url
+        self.connection_name = connection_name
 
 
 class AIOSqlAlchemySessionInterceptor(AppInterceptor):
@@ -54,11 +122,16 @@ class AIOSqlAlchemySessionInterceptor(AppInterceptor):
 
     @asynccontextmanager
     async def intercept(self, app_context: AppContext) -> AsyncGenerator[None, None]:
-        async with self.sessionmaker() as session:
-            with provide_session(self.config.connection_name, session):
+
+        async with self.sessionmaker() as session, session.begin() as tx:
+            token = ctx_default_connection_name.set(self.config.connection_name)
+            with providing_session(session, tx, self.config.connection_name):
                 try:
                     yield
-                    await session.commit()
+                    if tx.is_active:
+                        await tx.commit()
                 except Exception as e:
-                    await session.rollback()
+                    await tx.rollback()
                     raise e
+                finally:
+                    ctx_default_connection_name.reset(token)

{jararaca-0.3.11a2.dist-info → jararaca-0.3.11a4.dist-info}/METADATA

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

{jararaca-0.3.11a2.dist-info → jararaca-0.3.11a4.dist-info}/RECORD

@@ -1,9 +1,9 @@
-jararaca/__init__.py,sha256=4WO-Th3vY1_0SKdLyviZN2rftiX7R5yPVNPGJ9Mf5Y0,15633
+jararaca/__init__.py,sha256=LL97aPXyHyb-bjW4EYL2y33UjJER2GlvjMlZiTLioEw,16387
 jararaca/__main__.py,sha256=-O3vsB5lHdqNFjUtoELDF81IYFtR-DSiiFMzRaiSsv4,67
 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=gYdokdAWAPI9e5fQwkQofrcbE_ofJXr1kHc7wFRufnc,12283
+jararaca/cli.py,sha256=9TrlHdZGaqNO3Hg4HpBsTc9x8W3oFP9fVqjPR0rMzKk,24671
 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
@@ -27,10 +27,10 @@ jararaca/observability/decorators.py,sha256=XffBinFXdiNkY6eo8_1nkr_GapM0RUGBg0ai
 jararaca/observability/interceptor.py,sha256=GHkuGKFWftN7MDjvYeGFGEPnuJETNhtxRK6yuPrCrpU,1462
 jararaca/observability/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jararaca/observability/providers/otel.py,sha256=LgfoITdoQTCxKebfLcEfwMiG992wlWY_0AUTd2fo8hY,6065
-jararaca/persistence/base.py,sha256=Xfnpvj3yeLdpVBifH5W6AwPCLwL2ot0dpLzbPg1zwkQ,966
+jararaca/persistence/base.py,sha256=xnGUbsLNz3gO-9iJt-Sn5NY13Yc9-misP8wLwQuGGoM,1024
 jararaca/persistence/exports.py,sha256=Ghx4yoFaB4QVTb9WxrFYgmcSATXMNvrOvT8ybPNKXCA,62
 jararaca/persistence/interceptors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jararaca/persistence/interceptors/aiosqa_interceptor.py,sha256=H6ZjOdosYGCZUzKjugiXQwJkAbnsL4HnkZLOEQhULEc,1986
+jararaca/persistence/interceptors/aiosqa_interceptor.py,sha256=VOaoSFZtcCJTrdYxjLUtzkG6bWMVbOKT6WI1BP2hmls,4090
 jararaca/persistence/session.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jararaca/persistence/sort_filter.py,sha256=agggpN0YvNjUr6wJjy69NkaqxoDDW13ys9B3r85OujA,9226
 jararaca/persistence/utilities.py,sha256=imcV4Oi5kXNk6m9QF2-OsnFpcTRY4w5mBYLdEx5XTSQ,14296
@@ -66,8 +66,8 @@ jararaca/tools/metadata.py,sha256=7nlCDYgItNybentPSSCc2MLqN7IpBd0VyQzfjfQycVI,14
 jararaca/tools/typescript/interface_parser.py,sha256=35xbOrZDQDyTXdMrVZQ8nnFw79f28lJuLYNHAspIqi8,30492
 jararaca/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jararaca/utils/rabbitmq_utils.py,sha256=FPDP8ZVgvitZXV-oK73D7EIANsqUzXTW7HdpEKsIsyI,2811
-jararaca-0.3.11a2.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-jararaca-0.3.11a2.dist-info/METADATA,sha256=DwqkZR-ohqqoPQrhM-9bnnbltJN_v2Kgk75gbrcKfPE,4954
-jararaca-0.3.11a2.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-jararaca-0.3.11a2.dist-info/entry_points.txt,sha256=WIh3aIvz8LwUJZIDfs4EeH3VoFyCGEk7cWJurW38q0I,45
-jararaca-0.3.11a2.dist-info/RECORD,,
+jararaca-0.3.11a4.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+jararaca-0.3.11a4.dist-info/METADATA,sha256=VeC353GhTULAEFtJysdLpvMX1MBxRhwXsL35n4pCm5k,4954
+jararaca-0.3.11a4.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+jararaca-0.3.11a4.dist-info/entry_points.txt,sha256=WIh3aIvz8LwUJZIDfs4EeH3VoFyCGEk7cWJurW38q0I,45
+jararaca-0.3.11a4.dist-info/RECORD,,