jararaca 0.3.12a3__py3-none-any.whl → 0.3.12a5__py3-none-any.whl

jararaca/__init__.py

@@ -45,26 +45,47 @@ if TYPE_CHECKING:
     )
     from jararaca.rpc.http.backends.httpx import HTTPXHttpRPCAsyncBackend
     from jararaca.rpc.http.backends.otel import TracedRequestMiddleware
-    from jararaca.rpc.http.decorators import Body
+    from jararaca.rpc.http.decorators import (  # New request parameter decorators; Configuration decorators; Authentication classes; Middleware classes; Configuration classes; Exception classes
+        ApiKeyAuth,
+        AuthenticationMiddleware,
+        BasicAuth,
+        BearerTokenAuth,
+        Body,
+        CacheMiddleware,
+        ContentType,
+    )
     from jararaca.rpc.http.decorators import Delete as HttpDelete
+    from jararaca.rpc.http.decorators import (  # New request parameter decorators; Configuration decorators; Authentication classes; Middleware classes; Configuration classes; Exception classes
+        File,
+        FormData,
+    )
     from jararaca.rpc.http.decorators import Get as HttpGet
-    from jararaca.rpc.http.decorators import (
+    from jararaca.rpc.http.decorators import (  # New request parameter decorators; Configuration decorators; Authentication classes; Middleware classes; Configuration classes; Exception classes
         GlobalHttpErrorHandler,
         Header,
         HttpMapping,
         HttpRpcClientBuilder,
     )
     from jararaca.rpc.http.decorators import Patch as HttpPatch
-    from jararaca.rpc.http.decorators import PathParam
+    from jararaca.rpc.http.decorators import (  # New request parameter decorators; Configuration decorators; Authentication classes; Middleware classes; Configuration classes; Exception classes
+        PathParam,
+    )
     from jararaca.rpc.http.decorators import Post as HttpPost
     from jararaca.rpc.http.decorators import Put as HttpPut
-    from jararaca.rpc.http.decorators import (
+    from jararaca.rpc.http.decorators import (  # New request parameter decorators; Configuration decorators; Authentication classes; Middleware classes; Configuration classes; Exception classes
         Query,
         RequestAttribute,
+        RequestHook,
+        ResponseHook,
+        ResponseMiddleware,
         RestClient,
+        Retry,
+        RetryConfig,
         RouteHttpErrorHandler,
         RPCRequestNetworkError,
         RPCUnhandleError,
+        Timeout,
+        TimeoutException,
     )
 
     from .core.providers import ProviderSpec, Token
@@ -81,6 +102,8 @@ if TYPE_CHECKING:
     from .messagebus.publisher import use_publisher
     from .microservice import (
         Microservice,
+        is_shutting_down,
+        request_shutdown,
         use_app_context,
         use_app_transaction_context,
         use_app_tx_ctx_data,
@@ -186,6 +209,12 @@ if TYPE_CHECKING:
         "QueryInjector",
         "HttpMicroservice",
         "use_current_container",
+        "use_app_context",
+        "use_app_transaction_context",
+        "use_app_tx_ctx_data",
+        "is_shutting_down",
+        "request_shutdown",
+        "Microservice",
         "T_BASEMODEL",
         "DatedEntity",
         "BaseEntity",
@@ -208,7 +237,6 @@ if TYPE_CHECKING:
         "MessageBusController",
         "MessageHandler",
         "ScheduledAction",
-        "Microservice",
         "ProviderSpec",
         "Token",
         "AIOSqlAlchemySessionInterceptor",
@@ -242,9 +270,27 @@ if TYPE_CHECKING:
         "provide_ws_manager",
         "HttpRpcClientBuilder",
         "HTTPXHttpRPCAsyncBackend",
-        "use_app_context",
-        "use_app_transaction_context",
-        "use_app_tx_ctx_data",
+        # New request parameter decorators
+        "FormData",
+        "File",
+        # Configuration decorators
+        "Timeout",
+        "Retry",
+        "ContentType",
+        # Authentication classes
+        "BearerTokenAuth",
+        "BasicAuth",
+        "ApiKeyAuth",
+        # Middleware classes
+        "CacheMiddleware",
+        "AuthenticationMiddleware",
+        "ResponseMiddleware",
+        "RequestHook",
+        "ResponseHook",
+        # Configuration classes
+        "RetryConfig",
+        # Exception classes
+        "TimeoutException",
         "AppTransactionContext",
         "AppContext",
         "ControllerMemberReflect",
@@ -440,9 +486,27 @@ _dynamic_imports: "dict[str, tuple[str, str, str | None]]" = {
     "provide_ws_manager": (__SPEC_PARENT__, "presentation.websocket.context", None),
     "HttpRpcClientBuilder": (__SPEC_PARENT__, "rpc.http.decorators", None),
     "HTTPXHttpRPCAsyncBackend": (__SPEC_PARENT__, "rpc.http.backends.httpx", None),
+    # New HTTP RPC classes
+    "FormData": (__SPEC_PARENT__, "rpc.http.decorators", None),
+    "File": (__SPEC_PARENT__, "rpc.http.decorators", None),
+    "Timeout": (__SPEC_PARENT__, "rpc.http.decorators", None),
+    "Retry": (__SPEC_PARENT__, "rpc.http.decorators", None),
+    "ContentType": (__SPEC_PARENT__, "rpc.http.decorators", None),
+    "BearerTokenAuth": (__SPEC_PARENT__, "rpc.http.decorators", None),
+    "BasicAuth": (__SPEC_PARENT__, "rpc.http.decorators", None),
+    "ApiKeyAuth": (__SPEC_PARENT__, "rpc.http.decorators", None),
+    "CacheMiddleware": (__SPEC_PARENT__, "rpc.http.decorators", None),
+    "AuthenticationMiddleware": (__SPEC_PARENT__, "rpc.http.decorators", None),
+    "ResponseMiddleware": (__SPEC_PARENT__, "rpc.http.decorators", None),
+    "RequestHook": (__SPEC_PARENT__, "rpc.http.decorators", None),
+    "ResponseHook": (__SPEC_PARENT__, "rpc.http.decorators", None),
+    "RetryConfig": (__SPEC_PARENT__, "rpc.http.decorators", None),
+    "TimeoutException": (__SPEC_PARENT__, "rpc.http.decorators", None),
     "use_app_context": (__SPEC_PARENT__, "microservice", None),
     "use_app_transaction_context": (__SPEC_PARENT__, "microservice", None),
     "use_app_tx_ctx_data": (__SPEC_PARENT__, "microservice", None),
+    "is_shutting_down": (__SPEC_PARENT__, "microservice", None),
+    "request_shutdown": (__SPEC_PARENT__, "microservice", None),
     "AppContext": (__SPEC_PARENT__, "microservice", None),
     "AppInterceptor": (__SPEC_PARENT__, "microservice", None),
     "AppTransactionContext": (__SPEC_PARENT__, "microservice", None),

jararaca/messagebus/worker.py

@@ -49,6 +49,8 @@ from jararaca.microservice import (
     MessageBusTransactionData,
     Microservice,
     SchedulerTransactionData,
+    ShutdownState,
+    provide_shutdown_state,
 )
 from jararaca.scheduler.decorators import ScheduledActionData
 from jararaca.utils.rabbitmq_utils import RabbitmqUtils
@@ -129,6 +131,17 @@ class MessageBusConsumer(ABC):
         """Close all resources related to the consumer"""
 
 
+class _WorkerShutdownState(ShutdownState):
+    def __init__(self, shutdown_event: asyncio.Event):
+        self.shutdown_event = shutdown_event
+
+    def request_shutdown(self) -> None:
+        self.shutdown_event.set()
+
+    def is_shutdown_requested(self) -> bool:
+        return self.shutdown_event.is_set()
+
+
 class AioPikaMicroserviceConsumer(MessageBusConsumer):
     def __init__(
         self,
@@ -146,6 +159,7 @@ class AioPikaMicroserviceConsumer(MessageBusConsumer):
         self.incoming_map: dict[str, MessageHandlerData] = {}
         self.uow_context_provider = uow_context_provider
         self.shutdown_event = asyncio.Event()
+        self.shutdown_state = _WorkerShutdownState(self.shutdown_event)
         self.lock = asyncio.Lock()
         self.tasks: set[asyncio.Task[Any]] = set()
         self.connection: aio_pika.abc.AbstractConnection | None = None
@@ -832,18 +846,19 @@ class ScheduledMessageHandlerCallback:
         args: tuple[Any, ...],
         kwargs: dict[str, Any],
     ) -> None:
-        async with self.consumer.uow_context_provider(
-            AppTransactionContext(
-                controller_member_reflect=scheduled_action.controller_member,
-                transaction_data=SchedulerTransactionData(
-                    scheduled_to=datetime.now(UTC),
-                    cron_expression=scheduled_action.spec.cron,
-                    triggered_at=datetime.now(UTC),
-                ),
-            )
-        ):
+        with provide_shutdown_state(self.consumer.shutdown_state):
+            async with self.consumer.uow_context_provider(
+                AppTransactionContext(
+                    controller_member_reflect=scheduled_action.controller_member,
+                    transaction_data=SchedulerTransactionData(
+                        scheduled_to=datetime.now(UTC),
+                        cron_expression=scheduled_action.spec.cron,
+                        triggered_at=datetime.now(UTC),
+                    ),
+                )
+            ):
 
-            await scheduled_action.callable(*args, **kwargs)
+                await scheduled_action.callable(*args, **kwargs)
 
 
 class MessageHandlerCallback:
@@ -1133,83 +1148,86 @@ class MessageHandlerCallback:
         incoming_message_spec = MessageHandler.get_message_incoming(handler)
         assert incoming_message_spec is not None
 
-        async with self.consumer.uow_context_provider(
-            AppTransactionContext(
-                controller_member_reflect=handler_data.controller_member,
-                transaction_data=MessageBusTransactionData(
-                    message=builded_message,
-                    topic=routing_key,
-                ),
-            )
-        ):
-            ctx: AsyncContextManager[Any]
-            if incoming_message_spec.timeout is not None:
-                ctx = asyncio.timeout(incoming_message_spec.timeout)
-            else:
-                ctx = none_context()
-            async with ctx:
-                try:
-                    with provide_bus_message_controller(
-                        AioPikaMessageBusController(aio_pika_message)
-                    ):
-                        await handler(builded_message)
-                    if not incoming_message_spec.auto_ack:
-                        with suppress(aio_pika.MessageProcessError):
-                            # Use channel context for acknowledgement
-                            async with self.consumer.get_channel_ctx(self.queue_name):
-                                await aio_pika_message.ack()
-                except BaseException as base_exc:
-                    # Get message id for logging
-                    message_id = aio_pika_message.message_id or str(uuid.uuid4())
-
-                    # Extract retry count from headers if available
-                    headers = aio_pika_message.headers or {}
-                    retry_count = int(str(headers.get("x-retry-count", 0)))
-
-                    # Process exception handler if configured
-                    if incoming_message_spec.exception_handler is not None:
-                        try:
-                            incoming_message_spec.exception_handler(base_exc)
-                        except Exception as nested_exc:
+        with provide_shutdown_state(self.consumer.shutdown_state):
+            async with self.consumer.uow_context_provider(
+                AppTransactionContext(
+                    controller_member_reflect=handler_data.controller_member,
+                    transaction_data=MessageBusTransactionData(
+                        message=builded_message,
+                        topic=routing_key,
+                    ),
+                )
+            ):
+                ctx: AsyncContextManager[Any]
+                if incoming_message_spec.timeout is not None:
+                    ctx = asyncio.timeout(incoming_message_spec.timeout)
+                else:
+                    ctx = none_context()
+                async with ctx:
+                    try:
+                        with provide_bus_message_controller(
+                            AioPikaMessageBusController(aio_pika_message)
+                        ):
+                            await handler(builded_message)
+                        if not incoming_message_spec.auto_ack:
+                            with suppress(aio_pika.MessageProcessError):
+                                # Use channel context for acknowledgement
+                                async with self.consumer.get_channel_ctx(
+                                    self.queue_name
+                                ):
+                                    await aio_pika_message.ack()
+                    except BaseException as base_exc:
+                        # Get message id for logging
+                        message_id = aio_pika_message.message_id or str(uuid.uuid4())
+
+                        # Extract retry count from headers if available
+                        headers = aio_pika_message.headers or {}
+                        retry_count = int(str(headers.get("x-retry-count", 0)))
+
+                        # Process exception handler if configured
+                        if incoming_message_spec.exception_handler is not None:
+                            try:
+                                incoming_message_spec.exception_handler(base_exc)
+                            except Exception as nested_exc:
+                                logger.exception(
+                                    f"Error processing exception handler for message {message_id}: {base_exc} | {nested_exc}"
+                                )
+                        else:
                             logger.exception(
-                                f"Error processing exception handler for message {message_id}: {base_exc} | {nested_exc}"
+                                f"Error processing message {message_id} on topic {routing_key}: {str(base_exc)}"
                             )
-                    else:
-                        logger.exception(
-                            f"Error processing message {message_id} on topic {routing_key}: {str(base_exc)}"
-                        )
 
-                    # Handle rejection with retry logic
-                    if incoming_message_spec.requeue_on_exception:
-                        # Use our retry with backoff mechanism
-                        await self.handle_reject_message(
-                            aio_pika_message,
-                            requeue=False,  # Don't requeue directly, use our backoff mechanism
-                            retry_count=retry_count,
-                            exception=base_exc,
-                        )
-                    else:
-                        # Message shouldn't be retried, reject it
-                        await self.handle_reject_message(
-                            aio_pika_message, requeue=False, exception=base_exc
-                        )
-                else:
-                    # Message processed successfully, log and clean up any retry state
-                    message_id = aio_pika_message.message_id or str(uuid.uuid4())
-                    if message_id in self.retry_state:
-                        del self.retry_state[message_id]
-
-                    # Log success with retry information if applicable
-                    headers = aio_pika_message.headers or {}
-                    if "x-retry-count" in headers:
-                        retry_count = int(str(headers.get("x-retry-count", 0)))
-                        logger.info(
-                            f"Message {message_id}#{self.queue_name} processed successfully after {retry_count} retries"
-                        )
+                        # Handle rejection with retry logic
+                        if incoming_message_spec.requeue_on_exception:
+                            # Use our retry with backoff mechanism
+                            await self.handle_reject_message(
+                                aio_pika_message,
+                                requeue=False,  # Don't requeue directly, use our backoff mechanism
+                                retry_count=retry_count,
+                                exception=base_exc,
+                            )
+                        else:
+                            # Message shouldn't be retried, reject it
+                            await self.handle_reject_message(
+                                aio_pika_message, requeue=False, exception=base_exc
+                            )
                     else:
-                        logger.info(
-                            f"Message {message_id}#{self.queue_name} processed successfully"
-                        )
+                        # Message processed successfully, log and clean up any retry state
+                        message_id = aio_pika_message.message_id or str(uuid.uuid4())
+                        if message_id in self.retry_state:
+                            del self.retry_state[message_id]
+
+                        # Log success with retry information if applicable
+                        headers = aio_pika_message.headers or {}
+                        if "x-retry-count" in headers:
+                            retry_count = int(str(headers.get("x-retry-count", 0)))
+                            logger.info(
+                                f"Message {message_id}#{self.queue_name} processed successfully after {retry_count} retries"
+                            )
+                        else:
+                            logger.info(
+                                f"Message {message_id}#{self.queue_name} processed successfully"
+                            )
 
 
 @asynccontextmanager

jararaca/microservice.py

@@ -325,6 +325,48 @@ def provide_container(container: Container) -> Generator[None, None, None]:
             current_container_ctx.reset(token)
 
 
+class ShutdownState(Protocol):
+
+    def request_shutdown(self) -> None: ...
+
+    def is_shutdown_requested(self) -> bool: ...
+
+
+shutdown_state_ctx = ContextVar[ShutdownState]("shutdown_state")
+
+
+def is_shutting_down() -> bool:
+    """
+    Check if the application is in the process of shutting down.
+    """
+    return shutdown_state_ctx.get().is_shutdown_requested()
+
+
+def request_shutdown() -> None:
+    """
+    Request the application to shut down.
+    This will set the shutdown event, allowing the application to gracefully shut down.
+    """
+    shutdown_state_ctx.get().request_shutdown()
+
+
+@contextmanager
+def provide_shutdown_state(
+    state: ShutdownState,
+) -> Generator[None, None, None]:
+    """
+    Context manager to provide the shutdown state.
+    This is used to manage the shutdown event for the application.
+    """
+
+    token = shutdown_state_ctx.set(state)
+    try:
+        yield
+    finally:
+        with suppress(ValueError):
+            shutdown_state_ctx.reset(token)
+
+
 __all__ = [
     "AppTransactionContext",
     "AppInterceptor",

jararaca/presentation/server.py

@@ -1,4 +1,8 @@
+import os
+import signal
+import threading
 from contextlib import asynccontextmanager
+from signal import SIGINT, SIGTERM
 from typing import Any, AsyncGenerator
 
 from fastapi import Depends, FastAPI, Request, WebSocket
@@ -10,7 +14,9 @@ from jararaca.lifecycle import AppLifecycle
 from jararaca.microservice import (
     AppTransactionContext,
     HttpTransactionData,
+    ShutdownState,
     WebSocketTransactionData,
+    provide_shutdown_state,
 )
 from jararaca.presentation.decorators import RestController
 from jararaca.presentation.http_microservice import HttpMicroservice
@@ -76,10 +82,49 @@ class HttpAppLifecycle:
             yield
 
 
+class HttpShutdownState(ShutdownState):
+    def __init__(self) -> None:
+        self._requested = False
+        self.old_signal_handlers = {
+            SIGINT: signal.getsignal(SIGINT),
+            SIGTERM: signal.getsignal(SIGTERM),
+        }
+        self.thread_lock = threading.Lock()
+
+    def request_shutdown(self) -> None:
+        if not self._requested:
+            self._requested = True
+            os.kill(os.getpid(), SIGINT)
+
+    def is_shutdown_requested(self) -> bool:
+        return self._requested
+
+    def handle_signal(self, signum: int, frame: Any) -> None:
+        print(f"Received signal {signum}, initiating shutdown...")
+        if self._requested:
+            print("Shutdown already requested, ignoring signal.")
+            return
+        print("Requesting shutdown...")
+        self._requested = True
+
+        # remove the signal handler to prevent recursion
+        for sig in (SIGINT, SIGTERM):
+            if self.old_signal_handlers[sig] is not None:
+                signal.signal(sig, self.old_signal_handlers[sig])
+
+        signal.raise_signal(signum)
+
+    def setup_signal_handlers(self) -> None:
+        signal.signal(SIGINT, self.handle_signal)
+        signal.signal(SIGTERM, self.handle_signal)
+
+
 class HttpUowContextProviderDependency:
 
     def __init__(self, uow_provider: UnitOfWorkContextProvider) -> None:
         self.uow_provider = uow_provider
+        self.shutdown_state = HttpShutdownState()
+        self.shutdown_state.setup_signal_handlers()
 
     async def __call__(
         self, websocket: WebSocket = None, request: Request = None  # type: ignore
@@ -101,17 +146,18 @@ class HttpUowContextProviderDependency:
             "ControllerMemberReflect, but got: {}".format(type(member))
         )
 
-        async with self.uow_provider(
-            AppTransactionContext(
-                controller_member_reflect=member,
-                transaction_data=(
-                    HttpTransactionData(request=request)
-                    if request
-                    else WebSocketTransactionData(websocket=websocket)
-                ),
-            )
-        ):
-            yield
+        with provide_shutdown_state(self.shutdown_state):
+            async with self.uow_provider(
+                AppTransactionContext(
+                    controller_member_reflect=member,
+                    transaction_data=(
+                        HttpTransactionData(request=request)
+                        if request
+                        else WebSocketTransactionData(websocket=websocket)
+                    ),
+                )
+            ):
+                yield
 
 
 def create_http_server(

jararaca/rpc/http/__init__.py

@@ -0,0 +1,97 @@
+# HTTP RPC Module - Complete REST Client Implementation
+"""
+This module provides a complete REST client implementation with support for:
+- HTTP method decorators (@Get, @Post, @Put, @Patch, @Delete)
+- Request parameter decorators (@Query, @Header, @PathParam, @Body, @FormData, @File)
+- Configuration decorators (@Timeout, @Retry, @ContentType)
+- Authentication middleware (BearerTokenAuth, BasicAuth, ApiKeyAuth)
+- Caching and response middleware
+- Request/response hooks for customization
+"""
+
+from .backends.httpx import HTTPXHttpRPCAsyncBackend
+from .decorators import (  # HTTP Method decorators; Request parameter decorators; Configuration decorators; Client builder and core classes; Authentication classes; Middleware and hooks; Configuration classes; Data structures; Error handlers; Exceptions
+    ApiKeyAuth,
+    AuthenticationMiddleware,
+    BasicAuth,
+    BearerTokenAuth,
+    Body,
+    CacheMiddleware,
+    ContentType,
+    Delete,
+    File,
+    FormData,
+    Get,
+    GlobalHttpErrorHandler,
+    Header,
+    HttpMapping,
+    HttpRpcClientBuilder,
+    HttpRPCRequest,
+    HttpRPCResponse,
+    Patch,
+    PathParam,
+    Post,
+    Put,
+    Query,
+    RequestAttribute,
+    RequestHook,
+    ResponseHook,
+    ResponseMiddleware,
+    RestClient,
+    Retry,
+    RetryConfig,
+    RouteHttpErrorHandler,
+    RPCRequestNetworkError,
+    RPCUnhandleError,
+    Timeout,
+    TimeoutException,
+)
+
+__all__ = [
+    # HTTP Method decorators
+    "Get",
+    "Post",
+    "Put",
+    "Patch",
+    "Delete",
+    # Request parameter decorators
+    "Query",
+    "Header",
+    "PathParam",
+    "Body",
+    "FormData",
+    "File",
+    # Configuration decorators
+    "Timeout",
+    "Retry",
+    "ContentType",
+    # Client builder and core classes
+    "RestClient",
+    "HttpRpcClientBuilder",
+    "HttpMapping",
+    "RequestAttribute",
+    # Authentication classes
+    "BearerTokenAuth",
+    "BasicAuth",
+    "ApiKeyAuth",
+    "AuthenticationMiddleware",
+    # Middleware and hooks
+    "CacheMiddleware",
+    "ResponseMiddleware",
+    "RequestHook",
+    "ResponseHook",
+    # Configuration classes
+    "RetryConfig",
+    # Data structures
+    "HttpRPCRequest",
+    "HttpRPCResponse",
+    # Error handlers
+    "GlobalHttpErrorHandler",
+    "RouteHttpErrorHandler",
+    # Exceptions
+    "RPCRequestNetworkError",
+    "RPCUnhandleError",
+    "TimeoutException",
+    # Backend
+    "HTTPXHttpRPCAsyncBackend",
+]

jararaca/rpc/http/backends/__init__.py

@@ -0,0 +1,10 @@
+# HTTP RPC Backends
+"""
+Backend implementations for HTTP RPC clients.
+"""
+
+from .httpx import HTTPXHttpRPCAsyncBackend
+
+__all__ = [
+    "HTTPXHttpRPCAsyncBackend",
+]

jararaca/rpc/http/backends/httpx.py

@@ -1,3 +1,4 @@
+import time
 from urllib.parse import urljoin
 
 import httpx
@@ -7,34 +8,63 @@ from jararaca.rpc.http.decorators import (
     HttpRPCRequest,
     HttpRPCResponse,
     RPCRequestNetworkError,
+    TimeoutException,
 )
 
 
 class HTTPXHttpRPCAsyncBackend(HttpRPCAsyncBackend):
 
-    def __init__(self, prefix_url: str = ""):
+    def __init__(self, prefix_url: str = "", default_timeout: float = 30.0):
         self.prefix_url = prefix_url
+        self.default_timeout = default_timeout
 
     async def request(
         self,
         request: HttpRPCRequest,
     ) -> HttpRPCResponse:
 
-        async with httpx.AsyncClient() as client:
+        start_time = time.time()
+
+        # Prepare timeout
+        timeout = (
+            request.timeout if request.timeout is not None else self.default_timeout
+        )
+
+        # Prepare request kwargs
+        request_kwargs = {
+            "method": request.method,
+            "url": urljoin(self.prefix_url, request.url),
+            "headers": request.headers,
+            "params": request.query_params,
+            "timeout": timeout,
+        }
+
+        # Handle different content types
+        if request.form_data and request.files:
+            # Multipart form data with files
+            request_kwargs["data"] = request.form_data
+            request_kwargs["files"] = request.files
+        elif request.form_data:
+            # Form data only
+            request_kwargs["data"] = request.form_data
+        elif request.body:
+            # Raw body content
+            request_kwargs["content"] = request.body
 
+        async with httpx.AsyncClient() as client:
             try:
-                response = await client.request(
-                    method=request.method,
-                    url=urljoin(self.prefix_url, request.url),
-                    headers=request.headers,
-                    params=request.query_params,
-                    content=request.body,
-                )
+                response = await client.request(**request_kwargs)  # type: ignore[arg-type]
+
+                elapsed_time = time.time() - start_time
 
                 return HttpRPCResponse(
                     status_code=response.status_code,
                     data=response.content,
+                    headers=dict(response.headers),
+                    elapsed_time=elapsed_time,
                 )
+            except httpx.TimeoutException as err:
+                raise TimeoutException(f"Request timed out: {err}") from err
             except httpx.NetworkError as err:
                 raise RPCRequestNetworkError(
                     request=request, backend_request=err.request

jararaca/rpc/http/decorators.py

@@ -1,11 +1,16 @@
+import asyncio
 import inspect
+import json
+import time
 from dataclasses import dataclass
 from typing import (
     Any,
     Awaitable,
     Callable,
+    Dict,
     Iterable,
     Literal,
+    Optional,
     Protocol,
     Type,
     TypeVar,
@@ -15,6 +20,11 @@ from typing import (
 from pydantic import BaseModel
 
 DECORATED_FUNC = TypeVar("DECORATED_FUNC", bound=Callable[..., Awaitable[Any]])
+DECORATED_CLASS = TypeVar("DECORATED_CLASS", bound=Any)
+
+
+class TimeoutException(Exception):
+    """Exception raised when a request times out"""
 
 
 class HttpMapping:
@@ -95,7 +105,9 @@ class RequestAttribute:
         return []
 
     def __init__(
-        self, attribute_type: Literal["query", "header", "body", "param"], name: str
+        self,
+        attribute_type: Literal["query", "header", "body", "param", "form", "file"],
+        name: str,
     ):
         self.attribute_type = attribute_type
         self.name = name
@@ -129,7 +141,105 @@ class PathParam(RequestAttribute):
         super().__init__("param", name)
 
 
-DECORATED_CLASS = TypeVar("DECORATED_CLASS", bound=Any)
+class FormData(RequestAttribute):
+    """Decorator for form data parameters"""
+
+    def __init__(self, name: str):
+        super().__init__("form", name)
+
+
+class File(RequestAttribute):
+    """Decorator for file upload parameters"""
+
+    def __init__(self, name: str):
+        super().__init__("file", name)
+
+
+class Timeout:
+    """Decorator for setting request timeout"""
+
+    TIMEOUT_ATTR = "__request_timeout__"
+
+    def __init__(self, seconds: float):
+        self.seconds = seconds
+
+    def __call__(self, func: DECORATED_FUNC) -> DECORATED_FUNC:
+        setattr(func, self.TIMEOUT_ATTR, self)
+        return func
+
+    @staticmethod
+    def get(func: DECORATED_FUNC) -> Optional["Timeout"]:
+        return getattr(func, Timeout.TIMEOUT_ATTR, None)
+
+
+class RetryConfig:
+    """Configuration for retry behavior"""
+
+    def __init__(
+        self,
+        max_attempts: int = 3,
+        backoff_factor: float = 1.0,
+        retry_on_status_codes: Optional[list[int]] = None,
+    ):
+        self.max_attempts = max_attempts
+        self.backoff_factor = backoff_factor
+        self.retry_on_status_codes = retry_on_status_codes or [500, 502, 503, 504]
+
+
+class Retry:
+    """Decorator for retry configuration"""
+
+    RETRY_ATTR = "__request_retry__"
+
+    def __init__(self, config: RetryConfig):
+        self.config = config
+
+    def __call__(self, func: DECORATED_FUNC) -> DECORATED_FUNC:
+        setattr(func, self.RETRY_ATTR, self)
+        return func
+
+    @staticmethod
+    def get(func: DECORATED_FUNC) -> Optional["Retry"]:
+        return getattr(func, Retry.RETRY_ATTR, None)
+
+
+class ContentType:
+    """Decorator for specifying content type"""
+
+    CONTENT_TYPE_ATTR = "__content_type__"
+
+    def __init__(self, content_type: str):
+        self.content_type = content_type
+
+    def __call__(self, func: DECORATED_FUNC) -> DECORATED_FUNC:
+        setattr(func, self.CONTENT_TYPE_ATTR, self)
+        return func
+
+    @staticmethod
+    def get(func: DECORATED_FUNC) -> Optional["ContentType"]:
+        return getattr(func, ContentType.CONTENT_TYPE_ATTR, None)
+
+
+class ResponseMiddleware(Protocol):
+    """Protocol for response middleware"""
+
+    def on_response(
+        self, request: "HttpRPCRequest", response: "HttpRPCResponse"
+    ) -> "HttpRPCResponse": ...
+
+
+class RequestHook(Protocol):
+    """Protocol for request hooks"""
+
+    def before_request(self, request: "HttpRPCRequest") -> "HttpRPCRequest": ...
+
+
+class ResponseHook(Protocol):
+    """Protocol for response hooks"""
+
+    def after_response(
+        self, request: "HttpRPCRequest", response: "HttpRPCResponse"
+    ) -> "HttpRPCResponse": ...
 
 
 class RestClient:
@@ -159,9 +269,10 @@ class RestClient:
 
 @dataclass
 class HttpRPCResponse:
-
     status_code: int
     data: bytes
+    headers: Optional[Dict[str, str]] = None
+    elapsed_time: Optional[float] = None
 
 
 @dataclass
@@ -171,6 +282,9 @@ class HttpRPCRequest:
     headers: list[tuple[str, str]]
     query_params: dict[str, str]
     body: bytes | None
+    timeout: Optional[float] = None
+    form_data: Optional[Dict[str, Any]] = None
+    files: Optional[Dict[str, Any]] = None
 
 
 class RPCRequestNetworkError(Exception):
@@ -275,15 +389,130 @@ class RequestMiddleware(Protocol):
     def on_request(self, request: HttpRPCRequest) -> HttpRPCRequest: ...
 
 
+class AuthenticationMiddleware(RequestMiddleware):
+    """Base class for authentication middleware"""
+
+    def on_request(self, request: HttpRPCRequest) -> HttpRPCRequest:
+        return self.add_auth(request)
+
+    def add_auth(self, request: HttpRPCRequest) -> HttpRPCRequest:
+        raise NotImplementedError
+
+
+class BearerTokenAuth(AuthenticationMiddleware):
+    """Bearer token authentication middleware"""
+
+    def __init__(self, token: str):
+        self.token = token
+
+    def add_auth(self, request: HttpRPCRequest) -> HttpRPCRequest:
+        request.headers.append(("Authorization", f"Bearer {self.token}"))
+        return request
+
+
+class BasicAuth(AuthenticationMiddleware):
+    """Basic authentication middleware"""
+
+    def __init__(self, username: str, password: str):
+        import base64
+
+        credentials = base64.b64encode(f"{username}:{password}".encode()).decode()
+        self.credentials = credentials
+
+    def add_auth(self, request: HttpRPCRequest) -> HttpRPCRequest:
+        request.headers.append(("Authorization", f"Basic {self.credentials}"))
+        return request
+
+
+class ApiKeyAuth(AuthenticationMiddleware):
+    """API key authentication middleware"""
+
+    def __init__(self, api_key: str, header_name: str = "X-API-Key"):
+        self.api_key = api_key
+        self.header_name = header_name
+
+    def add_auth(self, request: HttpRPCRequest) -> HttpRPCRequest:
+        request.headers.append((self.header_name, self.api_key))
+        return request
+
+
+class CacheMiddleware(RequestMiddleware):
+    """Simple in-memory cache middleware"""
+
+    def __init__(self, ttl_seconds: int = 300):
+        self.cache: Dict[str, tuple[Any, float]] = {}
+        self.ttl_seconds = ttl_seconds
+
+    def _cache_key(self, request: HttpRPCRequest) -> str:
+        """Generate cache key from request"""
+        key_data = {
+            "method": request.method,
+            "url": request.url,
+            "query_params": request.query_params,
+            "headers": sorted(request.headers),
+        }
+        return str(hash(json.dumps(key_data, sort_keys=True)))
+
+    def on_request(self, request: HttpRPCRequest) -> HttpRPCRequest:
+        # Only cache GET requests
+        if request.method == "GET":
+            cache_key = self._cache_key(request)
+            if cache_key in self.cache:
+                cached_response, timestamp = self.cache[cache_key]
+                if time.time() - timestamp < self.ttl_seconds:
+                    # Return cached response (this needs to be handled in the client builder)
+                    setattr(request, "_cached_response", cached_response)
+        return request
+
+
 class HttpRpcClientBuilder:
 
     def __init__(
         self,
         backend: HttpRPCAsyncBackend,
         middlewares: list[RequestMiddleware] = [],
+        response_middlewares: list[ResponseMiddleware] = [],
+        request_hooks: list[RequestHook] = [],
+        response_hooks: list[ResponseHook] = [],
     ):
         self._backend = backend
         self._middlewares = middlewares
+        self._response_middlewares = response_middlewares
+        self._request_hooks = request_hooks
+        self._response_hooks = response_hooks
+
+    async def _execute_with_retry(
+        self, request: HttpRPCRequest, retry_config: Optional[RetryConfig]
+    ) -> HttpRPCResponse:
+        """Execute request with retry logic"""
+        if not retry_config:
+            return await self._backend.request(request)
+
+        last_exception = None
+        for attempt in range(retry_config.max_attempts):
+            try:
+                response = await self._backend.request(request)
+
+                # Check if we should retry based on status code
+                if response.status_code in retry_config.retry_on_status_codes:
+                    if attempt < retry_config.max_attempts - 1:
+                        wait_time = retry_config.backoff_factor * (2**attempt)
+                        await asyncio.sleep(wait_time)
+                        continue
+
+                return response
+
+            except Exception as e:
+                last_exception = e
+                if attempt < retry_config.max_attempts - 1:
+                    wait_time = retry_config.backoff_factor * (2**attempt)
+                    await asyncio.sleep(wait_time)
+                    continue
+                else:
+                    raise
+
+        # This should never be reached, but just in case
+        raise last_exception or Exception("Retry failed")
 
     def build(self, cls: type[T]) -> T:
         rest_client = RestClient.get(cls)
@@ -314,10 +543,17 @@ class HttpRpcClientBuilder:
                 headers: list[tuple[str, str]] = []
                 query_params = {}
                 body: Any = None
+                form_data: Dict[str, Any] = {}
+                files: Dict[str, Any] = {}
                 compiled_path = (
                     rest_client.base_path.rstrip("/") + "/" + mapping.path.lstrip("/")
                 )
 
+                # Get decorators for this method
+                timeout_config = Timeout.get(method_call)
+                retry_config = Retry.get(method_call)
+                content_type_config = ContentType.get(method_call)
+
                 for attr in request_attributes:
                     if attr.attribute_type == "header":
                         headers.append((attr.name, compiled_kwargs[attr.name]))
@@ -329,17 +565,33 @@ class HttpRpcClientBuilder:
                         compiled_path = compiled_path.replace(
                             f":{attr.name}", str(compiled_kwargs[attr.name])
                         )
+                    elif attr.attribute_type == "form":
+                        form_data[attr.name] = compiled_kwargs[attr.name]
+                    elif attr.attribute_type == "file":
+                        files[attr.name] = compiled_kwargs[attr.name]
 
                 body_content: bytes | None = None
 
+                # Handle different content types
                 if body is not None:
                     if isinstance(body, BaseModel):
                         body_content = body.model_dump_json().encode()
-                        headers.append(("Content-Type", "application/json"))
+                        if not content_type_config:
+                            headers.append(("Content-Type", "application/json"))
                     elif isinstance(body, bytes):
                         body_content = body
+                    elif isinstance(body, str):
+                        body_content = body.encode()
+                    elif isinstance(body, dict):
+                        body_content = json.dumps(body).encode()
+                        if not content_type_config:
+                            headers.append(("Content-Type", "application/json"))
                     else:
-                        raise ValueError("Invalid body type")
+                        raise ValueError(f"Invalid body type: {type(body)}")
+
+                # Apply custom content type if specified
+                if content_type_config:
+                    headers.append(("Content-Type", content_type_config.content_type))
 
                 request = HttpRPCRequest(
                     url=compiled_path,
@@ -347,12 +599,41 @@ class HttpRpcClientBuilder:
                     headers=headers,
                     query_params=query_params,
                     body=body_content,
+                    timeout=timeout_config.seconds if timeout_config else None,
+                    form_data=form_data if form_data else None,
+                    files=files if files else None,
                 )
 
+                # Apply request hooks
+                for hook in self._request_hooks:
+                    request = hook.before_request(request)
+
                 for middleware in self._middlewares:
                     request = middleware.on_request(request)
 
-                response = await self._backend.request(request)
+                # Check for cached response
+                if hasattr(request, "_cached_response"):
+                    response = getattr(request, "_cached_response")
+                else:
+                    # Execute request with retry if configured
+                    response = await self._execute_with_retry(
+                        request, retry_config.config if retry_config else None
+                    )
+
+                # Apply response middleware
+                for response_middleware in self._response_middlewares:
+                    response = response_middleware.on_response(request, response)
+
+                # Apply response hooks
+                for response_hook in self._response_hooks:
+                    response = response_hook.after_response(request, response)
+
+                # Cache response if using cache middleware and it's a GET request
+                if request.method == "GET":
+                    for middleware in self._middlewares:
+                        if isinstance(middleware, CacheMiddleware):
+                            cache_key = middleware._cache_key(request)
+                            middleware.cache[cache_key] = (response, time.time())
 
                 return_type = inspect.signature(method_call).return_annotation
 
@@ -407,13 +688,28 @@ __all__ = [
     "Header",
     "Body",
     "PathParam",
+    "FormData",
+    "File",
+    "Timeout",
+    "RetryConfig",
+    "Retry",
+    "ContentType",
     "RestClient",
     "HttpRPCAsyncBackend",
     "HttpRPCRequest",
     "HttpRPCResponse",
     "RPCRequestNetworkError",
+    "RPCUnhandleError",
     "HttpRpcClientBuilder",
     "RequestMiddleware",
+    "ResponseMiddleware",
+    "RequestHook",
+    "ResponseHook",
+    "AuthenticationMiddleware",
+    "BearerTokenAuth",
+    "BasicAuth",
+    "ApiKeyAuth",
+    "CacheMiddleware",
     "TracedRequestMiddleware",
     "GlobalHttpErrorHandler",
     "RouteHttpErrorHandler",

jararaca/tools/typescript/interface_parser.py

@@ -406,7 +406,7 @@ export type ResponseType =
 export interface HttpBackendRequest {
   method: string;
   path: string;
-  pathParams: { [key: string]: string };
+  pathParams: { [key: string]: any };
   headers: { [key: string]: string };
   query: { [key: string]: unknown };
   body: unknown;

{jararaca-0.3.12a3.dist-info → jararaca-0.3.12a5.dist-info}/METADATA

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

{jararaca-0.3.12a3.dist-info → jararaca-0.3.12a5.dist-info}/RECORD

@@ -1,7 +1,7 @@
 LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
 README.md,sha256=2qMM__t_MoLKZr4IY9tXjo-Jn6LKjuHMb1qbyXpgL08,3401
-pyproject.toml,sha256=Hiy7cJKBQIrdiYnBskiQEYruLl8LsGgsknkKCD2uSp8,2040
-jararaca/__init__.py,sha256=EdOPigKYraoG7I-Hl9V3XteqrbhdBS3xy1rUakh58lc,17949
+pyproject.toml,sha256=sh8QoSrsND1MonDpmTcmeZ9ycDIraZF48tey-OKC6ZQ,2040
+jararaca/__init__.py,sha256=qffDJwYvbPqMdlx3fi5qFBVF2ZQ89W09znjTGTe9J6I,20939
 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
@@ -23,8 +23,8 @@ jararaca/messagebus/interceptors/aiopika_publisher_interceptor.py,sha256=_DEHwIH
 jararaca/messagebus/interceptors/publisher_interceptor.py,sha256=ojy1bRhqMgrkQljcGGS8cd8-8pUjL8ZHjIUkdmaAnNM,1325
 jararaca/messagebus/message.py,sha256=U6cyd2XknX8mtm0333slz5fanky2PFLWCmokAO56vvU,819
 jararaca/messagebus/publisher.py,sha256=JTkxdKbvxvDWT8nK8PVEyyX061vYYbKQMxRHXrZtcEY,2173
-jararaca/messagebus/worker.py,sha256=CrSIejWMGII4_JK0aH4jxdj0oBJX4hSXY0SmVa6KURA,54187
-jararaca/microservice.py,sha256=rRIimfeP2-wf289PKoUbk9wrSdA0ga_qWz5JNgQ5IE0,9667
+jararaca/messagebus/worker.py,sha256=736rl6mBVxo-w5Y-jJe1w1ORPgVk16jlmTyVJueeAKs,55156
+jararaca/microservice.py,sha256=4uQWPH1Ytxl2tg4IK-M_6T-28X89ku4ObJXJyg9CDr4,10663
 jararaca/observability/decorators.py,sha256=MOIr2PttPYYvRwEdfQZEwD5RxKHOTv8UEy9n1YQVoKw,2281
 jararaca/observability/interceptor.py,sha256=U4ZLM0f8j6Q7gMUKKnA85bnvD-Qa0ii79Qa_X8KsXAQ,1498
 jararaca/observability/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -40,7 +40,7 @@ jararaca/presentation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3h
 jararaca/presentation/decorators.py,sha256=dNcK1xYWhdHVBeWDa8dhqh4z8yQcPkJZTQkfgLXz6RI,11655
 jararaca/presentation/hooks.py,sha256=WBbU5DG3-MAm2Ro2YraQyYG_HENfizYfyShL2ktHi6k,1980
 jararaca/presentation/http_microservice.py,sha256=g771JosV6jTY3hQtG-HkLOo-T0e-r3b3rp1ddt99Qf0,533
-jararaca/presentation/server.py,sha256=5joE17nnSiwR497Nerr-vcthKL4NRBzyf1KWM8DFgwQ,4682
+jararaca/presentation/server.py,sha256=Im-tei9EynKm1DO-63UIGeTJK5ZvxIhpAxbsYGn7ZW0,6244
 jararaca/presentation/websocket/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jararaca/presentation/websocket/base_types.py,sha256=AvUeeZ1TFhSiRMcYqZU1HaQNqSrcgTkC5R0ArP5dGmA,146
 jararaca/presentation/websocket/context.py,sha256=A6K5W3kqo9Hgeh1m6JiI7Cdz5SfbXcaICSVX7u1ARZo,1903
@@ -53,11 +53,11 @@ jararaca/reflect/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,
 jararaca/reflect/controller_inspect.py,sha256=UtV4pRIOqCoK4ogBTXQE0dyopEQ5LDFhwm-1iJvrkJc,2326
 jararaca/reflect/metadata.py,sha256=oTi0zIjCYkeBhs12PNTLc8GmzR6qWHdl3drlmamXLJo,1897
 jararaca/rpc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jararaca/rpc/http/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jararaca/rpc/http/backends/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jararaca/rpc/http/backends/httpx.py,sha256=2inHnHYF5f7HiidkwlPOK7ZFpc1jBklKxvVRla9knCE,1141
+jararaca/rpc/http/__init__.py,sha256=Xp7-d-cVj7EK1JloSUbSnGBfER5YwCfp7LCU6wCAf1c,2396
+jararaca/rpc/http/backends/__init__.py,sha256=Q1tIj1PTjB4__qTZndGMu4IjP5lbayLbQZJ4fZXcnAk,166
+jararaca/rpc/http/backends/httpx.py,sha256=nNHXBortLt0tWW1qTXMPtSuO1mkpQcNh5eplP_8zYEM,2246
 jararaca/rpc/http/backends/otel.py,sha256=Uc6CjHSCZ5hvnK1fNFv3ota5xzUFnvIl1JOpG380siA,807
-jararaca/rpc/http/decorators.py,sha256=oUSzgMGI8w6SoKiz3GltDbd3BWAuyY60F23cdRRNeiw,11897
+jararaca/rpc/http/decorators.py,sha256=0BCcmP_jolIAB73VeXm3TKyVr3AWbzkXzUVMGqYtqSQ,22145
 jararaca/rpc/http/httpx.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jararaca/scheduler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jararaca/scheduler/beat_worker.py,sha256=i_NyovjFhhLYuUivf2mwpVC27oQ9SGTFOHZ7Ec4jv6I,12076
@@ -66,12 +66,12 @@ jararaca/scheduler/types.py,sha256=4HEQOmVIDp-BYLSzqmqSFIio1bd51WFmgFPIzPpVu04,1
 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=HV8h4AxqUc_ACs5do4BSVlyxlRXzx7HqJtoVO9tfRnQ,2611
-jararaca/tools/typescript/interface_parser.py,sha256=Bux7DUjEQ8eAry_qZeKCIYz0aPaMO78_5wAPVErXGFo,31482
+jararaca/tools/typescript/interface_parser.py,sha256=foZ_A_lkyacmAq9TU6hUFv5ZnZcPZbbxcjtzFUu1A_o,31479
 jararaca/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jararaca/utils/rabbitmq_utils.py,sha256=ytdAFUyv-OBkaVnxezuJaJoLrmN7giZgtKeet_IsMBs,10918
 jararaca/utils/retry.py,sha256=DzPX_fXUvTqej6BQ8Mt2dvLo9nNlTBm7Kx2pFZ26P2Q,4668
-jararaca-0.3.12a3.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-jararaca-0.3.12a3.dist-info/METADATA,sha256=wspP7q-KGhpcjXzXfRPGdW14rjggwwhzGOFnhmhjgDE,4995
-jararaca-0.3.12a3.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-jararaca-0.3.12a3.dist-info/entry_points.txt,sha256=WIh3aIvz8LwUJZIDfs4EeH3VoFyCGEk7cWJurW38q0I,45
-jararaca-0.3.12a3.dist-info/RECORD,,
+jararaca-0.3.12a5.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+jararaca-0.3.12a5.dist-info/METADATA,sha256=1voFAjmPXB7wfDeF9-B0GSVSfzPG-wV1NR5ay_Tjkls,4995
+jararaca-0.3.12a5.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+jararaca-0.3.12a5.dist-info/entry_points.txt,sha256=WIh3aIvz8LwUJZIDfs4EeH3VoFyCGEk7cWJurW38q0I,45
+jararaca-0.3.12a5.dist-info/RECORD,,

pyproject.toml

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