jararaca 0.3.25__py3-none-any.whl → 0.3.28__py3-none-any.whl

jararaca/__init__.py

@@ -18,12 +18,17 @@ if TYPE_CHECKING:
         use_app_type,
     )
     from jararaca.observability.decorators import TracedClass, TracedFunc, traced_class
+    from jararaca.observability.fastapi_exception_handler import (
+        setup_fastapi_exception_handler,
+    )
     from jararaca.observability.hooks import (
         add_event,
         get_tracing_provider,
         record_exception,
+        set_span_attribute,
         set_span_status,
         spawn_trace,
+        start_span,
     )
     from jararaca.observability.interceptor import ObservabilityInterceptor
     from jararaca.observability.providers.otel import OtelObservabilityProvider
@@ -233,8 +238,11 @@ if TYPE_CHECKING:
         "TracedFunc",
         "TracedClass",
         "traced_class",
+        "start_span",
         "spawn_trace",
+        "set_span_attribute",
         "add_event",
+        "setup_fastapi_exception_handler",
         "set_span_status",
         "record_exception",
         "get_tracing_provider",
@@ -412,6 +420,13 @@ _dynamic_imports: "dict[str, tuple[str, str, str | None]]" = {
     "TracedClass": (__SPEC_PARENT__, "observability.decorators", None),
     "traced_class": (__SPEC_PARENT__, "observability.decorators", None),
     "spawn_trace": (__SPEC_PARENT__, "observability.hooks", None),
+    "setup_fastapi_exception_handler": (
+        __SPEC_PARENT__,
+        "observability.fastapi_exception_handler",
+        None,
+    ),
+    "set_span_attribute": (__SPEC_PARENT__, "observability.hooks", None),
+    "start_span": (__SPEC_PARENT__, "observability.hooks", None),
     "add_event": (__SPEC_PARENT__, "observability.hooks", None),
     "set_span_status": (__SPEC_PARENT__, "observability.hooks", None),
     "record_exception": (__SPEC_PARENT__, "observability.hooks", None),

jararaca/observability/constants.py

@@ -0,0 +1,3 @@
+TRACEPARENT_KEY = "traceparent"
+
+__all__ = ["TRACEPARENT_KEY"]

jararaca/observability/decorators.py

@@ -37,7 +37,7 @@ AttributeMap = Mapping[str, AttributeValue]
 
 class TracingContextProvider(Protocol):
 
-    def start_trace_context(
+    def start_span_context(
         self, trace_name: str, context_attributes: AttributeMap | None
     ) -> ContextManager[Any]: ...
 
@@ -56,7 +56,13 @@ class TracingContextProvider(Protocol):
         escaped: bool = False,
     ) -> None: ...
 
+    def set_span_attribute(
+        self,
+        key: str,
+        value: AttributeValue,
+    ) -> None: ...
 
+    def update_span_name(self, new_name: str) -> None: ...
 class TracingContextProviderFactory(Protocol):
 
     def root_setup(
@@ -117,7 +123,7 @@ class TracedFunc:
         ) -> Any:
 
             if ctx_provider := get_tracing_ctx_provider():
-                with ctx_provider.start_trace_context(
+                with ctx_provider.start_span_context(
                     self.trace_name,
                     self.trace_mapper(*args, **kwargs),
                 ):

jararaca/observability/fastapi_exception_handler.py

@@ -0,0 +1,33 @@
+from fastapi import FastAPI, Request, Response
+from fastapi.exception_handlers import (
+    http_exception_handler,
+    request_validation_exception_handler,
+)
+from fastapi.exceptions import RequestValidationError
+from fastapi.responses import JSONResponse
+from starlette.exceptions import HTTPException
+
+from jararaca.observability.constants import TRACEPARENT_KEY
+
+
+def setup_fastapi_exception_handler(
+    app: FastAPI, trace_header_name: str = "traceparent"
+) -> None:
+    async def base_http_exception_handler(
+        request: Request, exc: HTTPException | RequestValidationError
+    ) -> JSONResponse | Response:
+
+        if isinstance(exc, RequestValidationError):
+            response = await request_validation_exception_handler(request, exc)
+            response.headers[trace_header_name] = request.scope.get(TRACEPARENT_KEY, "")
+            return response
+        else:
+            err_response = await http_exception_handler(request, exc)
+
+            err_response.headers[trace_header_name] = request.scope.get(
+                TRACEPARENT_KEY, ""
+            )
+            return err_response
+
+    app.exception_handlers[HTTPException] = base_http_exception_handler
+    app.exception_handlers[RequestValidationError] = base_http_exception_handler

jararaca/observability/hooks.py

@@ -1,21 +1,23 @@
+import logging
 from contextlib import contextmanager
 from typing import Any, Generator, Literal
 
 from jararaca.observability.decorators import (
     AttributeMap,
+    AttributeValue,
     TracingContextProvider,
     get_tracing_ctx_provider,
 )
 
 
 @contextmanager
-def spawn_trace(
+def start_span(
     name: str,
     attributes: AttributeMap | None = None,
 ) -> Generator[None, Any, None]:
 
     if trace_context_provider := get_tracing_ctx_provider():
-        with trace_context_provider.start_trace_context(
+        with trace_context_provider.start_span_context(
             trace_name=name, context_attributes=attributes
         ):
             yield
@@ -23,6 +25,19 @@ def spawn_trace(
         yield
 
 
+def spawn_trace(
+    name: str,
+    attributes: AttributeMap | None = None,
+) -> None:
+    logging.warning(
+        "spawn_trace is deprecated, use start_span as context manager instead."
+    )
+    if trace_context_provider := get_tracing_ctx_provider():
+        trace_context_provider.start_span_context(
+            trace_name=name, context_attributes=attributes
+        )
+
+
 def add_event(
     name: str,
     attributes: AttributeMap | None = None,
@@ -55,5 +70,17 @@ def record_exception(
         )
 
 
+def set_span_attribute(
+    key: str,
+    value: AttributeValue,
+) -> None:
+
+    if trace_context_provider := get_tracing_ctx_provider():
+        trace_context_provider.set_span_attribute(
+            key=key,
+            value=value,
+        )
+
+
 def get_tracing_provider() -> TracingContextProvider | None:
     return get_tracing_ctx_provider()

jararaca/observability/providers/otel.py

@@ -34,8 +34,10 @@ from jararaca.microservice import (
     Microservice,
     use_app_transaction_context,
 )
+from jararaca.observability.constants import TRACEPARENT_KEY
 from jararaca.observability.decorators import (
     AttributeMap,
+    AttributeValue,
     TracingContextProvider,
     TracingContextProviderFactory,
 )
@@ -50,7 +52,7 @@ class OtelTracingContextProvider(TracingContextProvider):
         self.app_context = app_context
 
     @contextmanager
-    def start_trace_context(
+    def start_span_context(
         self,
         trace_name: str,
         context_attributes: AttributeMap | None,
@@ -82,6 +84,14 @@ class OtelTracingContextProvider(TracingContextProvider):
         span = trace.get_current_span()
         span.record_exception(exception, attributes=attributes, escaped=escaped)
 
+    def set_span_attribute(self, key: str, value: AttributeValue) -> None:
+        span = trace.get_current_span()
+        span.set_attribute(key, value)
+
+    def update_span_name(self, new_name: str) -> None:
+        span = trace.get_current_span()
+        span.update_name(new_name)
+
 
 class OtelTracingContextProviderFactory(TracingContextProviderFactory):
 
@@ -185,10 +195,15 @@ class OtelTracingContextProviderFactory(TracingContextProviderFactory):
             },
         ) as root_span:
             cx = root_span.get_span_context()
+            span_traceparent_id = hex(cx.trace_id)[2:].rjust(32, "0")
             if app_tx_ctx.transaction_data.context_type == "http":
-                app_tx_ctx.transaction_data.response.headers["traceparent"] = hex(
-                    cx.trace_id
-                )[2:].rjust(32, "0")
+                app_tx_ctx.transaction_data.request.scope[TRACEPARENT_KEY] = (
+                    span_traceparent_id
+                )
+            elif app_tx_ctx.transaction_data.context_type == "websocket":
+                app_tx_ctx.transaction_data.websocket.scope[TRACEPARENT_KEY] = (
+                    span_traceparent_id
+                )
             tracing_headers: ImplicitHeaders = {}
             TraceContextTextMapPropagator().inject(tracing_headers)
             W3CBaggagePropagator().inject(tracing_headers)

jararaca/tools/typescript/interface_parser.py

@@ -30,7 +30,7 @@ from pydantic import BaseModel, PlainValidator, RootModel
 from pydantic_core import PydanticUndefined
 
 from jararaca.microservice import Microservice
-from jararaca.presentation.decorators import HttpMapping, RestController
+from jararaca.presentation.decorators import HttpMapping, RestController, UseMiddleware
 from jararaca.presentation.websocket.decorators import RegisterWebSocketMessage
 from jararaca.presentation.websocket.websocket_interceptor import (
     WebSocketMessageWrapper,
@@ -841,6 +841,8 @@ def write_rest_controller_to_typescript_interface(
         inspect.getmembers(controller, predicate=inspect.isfunction), key=lambda x: x[0]
     )
 
+    class_usemiddlewares = UseMiddleware.get_middlewares(controller)
+
     for name, member in member_items:
         if (mapping := HttpMapping.get_http_mapping(member)) is not None:
             return_type = member.__annotations__.get("return")
@@ -862,6 +864,39 @@ def write_rest_controller_to_typescript_interface(
                 member, rest_controller, mapping
             )
 
+            # Extract parameters from controller-level middlewares
+            for middleware_type in rest_controller.middlewares:
+                middleware_params, middleware_mapped_types = (
+                    extract_middleware_parameters(
+                        middleware_type, rest_controller, mapping
+                    )
+                )
+                arg_params_spec.extend(middleware_params)
+                parametes_mapped_types.update(middleware_mapped_types)
+
+            # Extract parameters from class-level UseMiddleware decorators
+            for middleware_instance in class_usemiddlewares:
+                middleware_params, middleware_mapped_types = (
+                    extract_middleware_parameters(
+                        middleware_instance.middleware, rest_controller, mapping
+                    )
+                )
+                arg_params_spec.extend(middleware_params)
+                parametes_mapped_types.update(middleware_mapped_types)
+
+            # Extract parameters from method-level middlewares (UseMiddleware)
+            # Get the method from the class to access its middleware decorators
+            class_method = getattr(controller, name, None)
+            if class_method:
+                for middleware_instance in UseMiddleware.get_middlewares(class_method):
+                    middleware_params, middleware_mapped_types = (
+                        extract_middleware_parameters(
+                            middleware_instance.middleware, rest_controller, mapping
+                        )
+                    )
+                    arg_params_spec.extend(middleware_params)
+                    parametes_mapped_types.update(middleware_mapped_types)
+
             for param in parametes_mapped_types:
                 mapped_types.update(extract_all_envolved_types(param))
 
@@ -882,6 +917,8 @@ def write_rest_controller_to_typescript_interface(
 
             # Properly handle path joining to avoid double slashes
             controller_path = rest_controller.path or ""
+            # Also apply path transformation to the controller path
+            controller_path = parse_path_with_params(controller_path, arg_params_spec)
             path_parts = []
 
             if controller_path and controller_path.strip("/"):
@@ -1008,8 +1045,6 @@ class HttpParemeterSpec:
 def parse_path_with_params(path: str, parameters: list[HttpParemeterSpec]) -> str:
     # Use a regular expression to match both simple parameters {param} and
     # parameters with converters {param:converter}
-    import re
-
     pattern = re.compile(r"{([^:}]+)(?::[^}]*)?}")
 
     # For each parameter found in the path, replace it with :param format
@@ -1022,6 +1057,212 @@ def parse_path_with_params(path: str, parameters: list[HttpParemeterSpec]) -> st
     return path
 
 
+def extract_middleware_parameters(
+    middleware_type: type,
+    controller: RestController,
+    mapping: HttpMapping,
+) -> tuple[list[HttpParemeterSpec], set[Any]]:
+    """
+    Extract parameters from a middleware class's intercept method.
+    """
+    parameters_list: list[HttpParemeterSpec] = []
+    mapped_types: set[Any] = set()
+
+    # Get the intercept method from the middleware class
+    if not hasattr(middleware_type, "intercept"):
+        return parameters_list, mapped_types
+
+    intercept_method = getattr(middleware_type, "intercept")
+
+    # Use the same logic as extract_parameters but specifically for the intercept method
+    try:
+        signature = inspect.signature(intercept_method)
+        for parameter_name, parameter in signature.parameters.items():
+            # Skip 'self' parameter
+            if parameter_name == "self":
+                continue
+
+            parameter_type = parameter.annotation
+            if parameter_type == inspect.Parameter.empty:
+                continue
+
+            if parameter_type in EXCLUDED_REQUESTS_TYPES:
+                continue
+
+            if get_origin(parameter_type) == Annotated:
+                unwrapped_type, all_metadata = unwrap_annotated_type(parameter_type)
+                # Look for FastAPI parameter annotations in all metadata layers
+                annotated_type_hook = None
+                for metadata in all_metadata:
+                    if isinstance(
+                        metadata, (Header, Cookie, Form, Body, Query, Path, Depends)
+                    ):
+                        annotated_type_hook = metadata
+                        break
+
+                if annotated_type_hook is None and all_metadata:
+                    # Fallback to first metadata if no FastAPI annotation found
+                    annotated_type_hook = all_metadata[0]
+
+                annotated_type = unwrapped_type
+                if isinstance(annotated_type_hook, Header):
+                    mapped_types.add(str)
+                    parameters_list.append(
+                        HttpParemeterSpec(
+                            type_="header",
+                            name=parameter_name,
+                            required=True,
+                            argument_type_str=get_field_type_for_ts(str),
+                        )
+                    )
+                elif isinstance(annotated_type_hook, Cookie):
+                    mapped_types.add(str)
+                    parameters_list.append(
+                        HttpParemeterSpec(
+                            type_="cookie",
+                            name=parameter_name,
+                            required=True,
+                            argument_type_str=get_field_type_for_ts(str),
+                        )
+                    )
+                elif isinstance(annotated_type_hook, Form):
+                    mapped_types.add(annotated_type)
+                    parameters_list.append(
+                        HttpParemeterSpec(
+                            type_="form",
+                            name=parameter_name,
+                            required=True,
+                            argument_type_str=get_field_type_for_ts(annotated_type),
+                        )
+                    )
+                elif isinstance(annotated_type_hook, Body):
+                    mapped_types.update(extract_all_envolved_types(parameter_type))
+                    # For body parameters, use Input suffix if it's a split model
+                    context_suffix = (
+                        "Input"
+                        if (
+                            inspect.isclass(parameter_type)
+                            and hasattr(parameter_type, "__dict__")
+                            and SplitInputOutput.is_split_model(parameter_type)
+                        )
+                        else ""
+                    )
+                    parameters_list.append(
+                        HttpParemeterSpec(
+                            type_="body",
+                            name=parameter_name,
+                            required=True,
+                            argument_type_str=get_field_type_for_ts(
+                                parameter_type, context_suffix
+                            ),
+                        )
+                    )
+                elif isinstance(annotated_type_hook, Query):
+                    mapped_types.add(parameter_type)
+                    # For query parameters, use Input suffix if it's a split model
+                    context_suffix = (
+                        "Input"
+                        if (
+                            inspect.isclass(parameter_type)
+                            and hasattr(parameter_type, "__dict__")
+                            and SplitInputOutput.is_split_model(parameter_type)
+                        )
+                        else ""
+                    )
+                    parameters_list.append(
+                        HttpParemeterSpec(
+                            type_="query",
+                            name=parameter_name,
+                            required=True,
+                            argument_type_str=get_field_type_for_ts(
+                                parameter_type, context_suffix
+                            ),
+                        )
+                    )
+                elif isinstance(annotated_type_hook, Path):
+                    mapped_types.add(parameter_type)
+                    # For path parameters, use Input suffix if it's a split model
+                    context_suffix = (
+                        "Input"
+                        if (
+                            inspect.isclass(parameter_type)
+                            and hasattr(parameter_type, "__dict__")
+                            and SplitInputOutput.is_split_model(parameter_type)
+                        )
+                        else ""
+                    )
+                    parameters_list.append(
+                        HttpParemeterSpec(
+                            type_="path",
+                            name=parameter_name,
+                            required=True,
+                            argument_type_str=get_field_type_for_ts(
+                                parameter_type, context_suffix
+                            ),
+                        )
+                    )
+                elif isinstance(annotated_type_hook, Depends):
+                    # For Dependencies, recursively extract parameters
+                    depends_hook = (
+                        annotated_type_hook.dependency or parameter_type.__args__[0]
+                    )
+                    if isinstance(depends_hook, HTTPBase):
+                        # Skip HTTP authentication dependencies
+                        pass
+                    else:
+                        # TODO: We might need to recursively extract from dependencies
+                        # For now, skip to avoid infinite recursion
+                        pass
+            else:
+                # Handle non-annotated parameters - check if they are path parameters
+                mapped_types.add(parameter_type)
+
+                # Check if parameter matches path parameters in controller or method paths
+                if (
+                    # Match both simple parameters {param} and parameters with converters {param:converter}
+                    re.search(f"{{{parameter_name}(:.*?)?}}", controller.path)
+                    is not None
+                    or re.search(f"{{{parameter_name}(:.*?)?}}", mapping.path)
+                    is not None
+                ):
+                    # This is a path parameter
+                    context_suffix = (
+                        "Input"
+                        if (
+                            inspect.isclass(parameter_type)
+                            and hasattr(parameter_type, "__dict__")
+                            and SplitInputOutput.is_split_model(parameter_type)
+                        )
+                        else ""
+                    )
+                    parameters_list.append(
+                        HttpParemeterSpec(
+                            type_="path",
+                            name=parameter_name,
+                            required=True,
+                            argument_type_str=get_field_type_for_ts(
+                                parameter_type, context_suffix
+                            ),
+                        )
+                    )
+                elif is_primitive(parameter_type):
+                    # Default to query parameters for simple types that aren't in the path
+                    parameters_list.append(
+                        HttpParemeterSpec(
+                            type_="query",
+                            name=parameter_name,
+                            required=True,
+                            argument_type_str=get_field_type_for_ts(parameter_type),
+                        )
+                    )
+
+    except (ValueError, TypeError):
+        # If we can't inspect the signature, return empty
+        pass
+
+    return parameters_list, mapped_types
+
+
 def mount_parametes_arguments(parameters: list[HttpParemeterSpec]) -> str:
     return ", ".join(
         [f"{parameter.name}: {parameter.argument_type_str}" for parameter in parameters]

{jararaca-0.3.25.dist-info → jararaca-0.3.28.dist-info}/METADATA

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

{jararaca-0.3.25.dist-info → jararaca-0.3.28.dist-info}/RECORD

@@ -1,7 +1,7 @@
 LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
 README.md,sha256=YmCngjU8llW0l7L3tuXkkfr8qH7V9aBMgfp2jEzeiKg,3517
-pyproject.toml,sha256=iPlQyxxgFBxw9owR11Cxr3UFWKstcQErqL_eGuOXxFg,2739
-jararaca/__init__.py,sha256=zQRbt5BrXFVvJW8pKaA9_KdkGFB6Njmr-9SyX0ZfenM,23331
+pyproject.toml,sha256=CEt_9xw3r5w6k6x7hD62Gb3uU3hHAyMaAmldYFK7jjM,2739
+jararaca/__init__.py,sha256=gp2ib_dYm5EP97FY3E8Av4CDCbgX6vuQhGNvNBpu0IQ,23866
 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
@@ -26,11 +26,13 @@ jararaca/messagebus/message.py,sha256=U6cyd2XknX8mtm0333slz5fanky2PFLWCmokAO56vv
 jararaca/messagebus/publisher.py,sha256=JTkxdKbvxvDWT8nK8PVEyyX061vYYbKQMxRHXrZtcEY,2173
 jararaca/messagebus/worker.py,sha256=DiKDUhcU4rEjjA_3KqCmnN3X5yyokZq_-SbLryjS_PM,69237
 jararaca/microservice.py,sha256=DW4RVeqgrx4J-dAg17sbzTn_sLXuvV1UOQFde2fpqds,11471
-jararaca/observability/decorators.py,sha256=xTt4HEmpm_m1OUS29kaoZLMCT2YYToJUzQziepl8qfQ,6062
-jararaca/observability/hooks.py,sha256=vQCxb5m4uFse0lJIAuzSd84acu7iGDNgf4kpaWYkju8,1499
+jararaca/observability/constants.py,sha256=quhqXBjDWVrr8Vr3tglgYo7zsQyz_y-z_dtqfUzYaa8,63
+jararaca/observability/decorators.py,sha256=W6RpGBUPJJX-FiYhp3HaCC-fh7-FZwDG4gBVZiE9dKU,6229
+jararaca/observability/fastapi_exception_handler.py,sha256=jSLhuR5Og3vRnIoZucRA5jPnvR6DEsM1ax7tQuEo5rc,1264
+jararaca/observability/hooks.py,sha256=ATGFPQxhkry1NdW18ywJ9onstlnW8Yx2FD487eY9M8o,2156
 jararaca/observability/interceptor.py,sha256=U4ZLM0f8j6Q7gMUKKnA85bnvD-Qa0ii79Qa_X8KsXAQ,1498
 jararaca/observability/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jararaca/observability/providers/otel.py,sha256=DCNjGhcpF-XdlGTiYoQg9F_1ftcggTItDfJ_PjlZm0s,10808
+jararaca/observability/providers/otel.py,sha256=vsaiIDWuSbpZ4UyzRMSH64o4BxzsZzO7P39mJHUD6rU,11442
 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
@@ -72,12 +74,12 @@ jararaca/tools/app_config/decorators.py,sha256=-ckkMZ1dswOmECdo1rFrZ15UAku--txaN
 jararaca/tools/app_config/interceptor.py,sha256=HV8h4AxqUc_ACs5do4BSVlyxlRXzx7HqJtoVO9tfRnQ,2611
 jararaca/tools/typescript/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jararaca/tools/typescript/decorators.py,sha256=2NXFI6MiqpjM8rmrje38dR5StRlqdzYOmPASgyLIHeo,4267
-jararaca/tools/typescript/interface_parser.py,sha256=yOSuOXKOeG0soGFo0fKiZIabu4YwnvIKk-Zss8UPAuE,55174
+jararaca/tools/typescript/interface_parser.py,sha256=VBx-TYQPjAiHLiYgzGdRl_p4xDbdx4GvJtQhDBrQx7g,66210
 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.25.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-jararaca-0.3.25.dist-info/METADATA,sha256=NfiyjoAO1CUVU8LTDyIImqCdgUiX7IKrU3XRhcMPTgI,5149
-jararaca-0.3.25.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-jararaca-0.3.25.dist-info/entry_points.txt,sha256=WIh3aIvz8LwUJZIDfs4EeH3VoFyCGEk7cWJurW38q0I,45
-jararaca-0.3.25.dist-info/RECORD,,
+jararaca-0.3.28.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+jararaca-0.3.28.dist-info/METADATA,sha256=5yQgnOm6ZduUsne5HQP-uq8_wgAZX-bOA3QeX4oTbgI,5149
+jararaca-0.3.28.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+jararaca-0.3.28.dist-info/entry_points.txt,sha256=WIh3aIvz8LwUJZIDfs4EeH3VoFyCGEk7cWJurW38q0I,45
+jararaca-0.3.28.dist-info/RECORD,,

pyproject.toml

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