jararaca 0.3.12a22__tar.gz → 0.3.14__tar.gz

{jararaca-0.3.12a22 → jararaca-0.3.14}/PKG-INFO

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

{jararaca-0.3.12a22 → jararaca-0.3.14}/pyproject.toml

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

{jararaca-0.3.12a22 → jararaca-0.3.14}/src/jararaca/__init__.py

@@ -11,7 +11,12 @@ if TYPE_CHECKING:
         retry_later,
         use_bus_message_controller,
     )
-    from jararaca.microservice import AppContext, AppInterceptor, AppTransactionContext
+    from jararaca.microservice import (
+        AppContext,
+        AppInterceptor,
+        AppTransactionContext,
+        use_app_type,
+    )
     from jararaca.observability.interceptor import ObservabilityInterceptor
     from jararaca.observability.providers.otel import OtelObservabilityProvider
     from jararaca.persistence.sort_filter import (
@@ -308,6 +313,7 @@ if TYPE_CHECKING:
         # Exception classes
         "TimeoutException",
         "AppTransactionContext",
+        "use_app_type",
         "AppContext",
         "ControllerMemberReflect",
         "ControllerReflect",
@@ -544,6 +550,7 @@ _dynamic_imports: "dict[str, tuple[str, str, str | None]]" = {
     "AppContext": (__SPEC_PARENT__, "microservice", None),
     "AppInterceptor": (__SPEC_PARENT__, "microservice", None),
     "AppTransactionContext": (__SPEC_PARENT__, "microservice", None),
+    "use_app_type": (__SPEC_PARENT__, "microservice", None),
     "ControllerMemberReflect": (__SPEC_PARENT__, "reflect.controller_inspect", None),
     "ControllerReflect": (__SPEC_PARENT__, "reflect.controller_inspect", None),
 }

{jararaca-0.3.12a22 → jararaca-0.3.14}/src/jararaca/messagebus/worker.py

@@ -58,6 +58,7 @@ from jararaca.microservice import (
     SchedulerTransactionData,
     ShutdownState,
     provide_shutdown_state,
+    providing_app_type,
 )
 from jararaca.scheduler.decorators import ScheduledActionData
 from jararaca.utils.rabbitmq_utils import RabbitmqUtils
@@ -1725,61 +1726,64 @@ class MessageBusWorker:
     async def start_async(self) -> None:
         all_message_handlers_set: MESSAGE_HANDLER_DATA_SET = set()
         all_scheduled_actions_set: SCHEDULED_ACTION_DATA_SET = set()
-        async with self.lifecycle():
-            for instance_class in self.app.controllers:
-                controller = MessageBusController.get_messagebus(instance_class)
-
-                if controller is None:
-                    continue
-
-                instance: Any = self.container.get_by_type(instance_class)
-
-                factory = controller.get_messagebus_factory()
-                handlers, schedulers = factory(instance)
-
-                message_handler_data_map: dict[str, MessageHandlerData] = {}
-                all_scheduled_actions_set.update(schedulers)
-                for handler_data in handlers:
-                    message_type = handler_data.spec.message_type
-                    topic = message_type.MESSAGE_TOPIC
-
-                    # Filter handlers by name if specified
-                    if (
-                        self.handler_names is not None
-                        and handler_data.spec.name is not None
-                    ):
-                        if handler_data.spec.name not in self.handler_names:
-                            continue
-                    elif (
-                        self.handler_names is not None
-                        and handler_data.spec.name is None
-                    ):
-                        # Skip handlers without names when filtering is requested
-                        continue
+        with providing_app_type("worker"):
+            async with self.lifecycle():
+                for instance_class in self.app.controllers:
+                    controller = MessageBusController.get_messagebus(instance_class)
 
-                    if (
-                        topic in message_handler_data_map
-                        and message_type.MESSAGE_TYPE == "task"
-                    ):
-                        logger.warning(
-                            "Task handler for topic '%s' already registered. Skipping"
-                            % topic
-                        )
+                    if controller is None:
                         continue
-                    message_handler_data_map[topic] = handler_data
-                    all_message_handlers_set.add(handler_data)
 
-            broker_backend = get_message_broker_backend_from_url(url=self.backend_url)
+                    instance: Any = self.container.get_by_type(instance_class)
 
-            consumer = self._consumer = create_message_bus(
-                broker_url=self.broker_url,
-                broker_backend=broker_backend,
-                scheduled_actions=all_scheduled_actions_set,
-                message_handler_set=all_message_handlers_set,
-                uow_context_provider=self.uow_context_provider,
-            )
+                    factory = controller.get_messagebus_factory()
+                    handlers, schedulers = factory(instance)
+
+                    message_handler_data_map: dict[str, MessageHandlerData] = {}
+                    all_scheduled_actions_set.update(schedulers)
+                    for handler_data in handlers:
+                        message_type = handler_data.spec.message_type
+                        topic = message_type.MESSAGE_TOPIC
+
+                        # Filter handlers by name if specified
+                        if (
+                            self.handler_names is not None
+                            and handler_data.spec.name is not None
+                        ):
+                            if handler_data.spec.name not in self.handler_names:
+                                continue
+                        elif (
+                            self.handler_names is not None
+                            and handler_data.spec.name is None
+                        ):
+                            # Skip handlers without names when filtering is requested
+                            continue
+
+                        if (
+                            topic in message_handler_data_map
+                            and message_type.MESSAGE_TYPE == "task"
+                        ):
+                            logger.warning(
+                                "Task handler for topic '%s' already registered. Skipping"
+                                % topic
+                            )
+                            continue
+                        message_handler_data_map[topic] = handler_data
+                        all_message_handlers_set.add(handler_data)
+
+                broker_backend = get_message_broker_backend_from_url(
+                    url=self.backend_url
+                )
+
+                consumer = self._consumer = create_message_bus(
+                    broker_url=self.broker_url,
+                    broker_backend=broker_backend,
+                    scheduled_actions=all_scheduled_actions_set,
+                    message_handler_set=all_message_handlers_set,
+                    uow_context_provider=self.uow_context_provider,
+                )
 
-            await consumer.consume()
+                await consumer.consume()
 
     def start_sync(self) -> None:
 

{jararaca-0.3.12a22 → jararaca-0.3.14}/src/jararaca/microservice.py

@@ -59,6 +59,8 @@ class WebSocketTransactionData:
     context_type: Literal["websocket"] = "websocket"
 
 
+APP_TYPE = Literal["http", "worker", "beat"]
+
 TransactionData = (
     MessageBusTransactionData
     | HttpTransactionData
@@ -367,6 +369,32 @@ def provide_shutdown_state(
             shutdown_state_ctx.reset(token)
 
 
+app_type_ctx = ContextVar[APP_TYPE]("app_type")
+
+
+def use_app_type() -> APP_TYPE:
+    """
+    Returns the current application type.
+    This function is used to access the application type in the context of an application transaction.
+    If no context is set, it raises a LookupError.
+    """
+    return app_type_ctx.get()
+
+
+@contextmanager
+def providing_app_type(app_type: APP_TYPE) -> Generator[None, None, None]:
+    """
+    Context manager to provide the application type.
+    This is used to set the application type for the current transaction.
+    """
+    token = app_type_ctx.set(app_type)
+    try:
+        yield
+    finally:
+        with suppress(ValueError):
+            app_type_ctx.reset(token)
+
+
 __all__ = [
     "AppTransactionContext",
     "AppInterceptor",

{jararaca-0.3.12a22 → jararaca-0.3.14}/src/jararaca/presentation/server.py

@@ -17,6 +17,7 @@ from jararaca.microservice import (
     ShutdownState,
     WebSocketTransactionData,
     provide_shutdown_state,
+    providing_app_type,
 )
 from jararaca.presentation.decorators import RestController
 from jararaca.presentation.http_microservice import HttpMicroservice
@@ -37,49 +38,30 @@ class HttpAppLifecycle:
 
     @asynccontextmanager
     async def __call__(self, api: FastAPI) -> AsyncGenerator[None, None]:
-        async with self.lifecycle():
+        with providing_app_type("http"):
+            async with self.lifecycle():
 
-            # websocket_interceptors = [
-            #     interceptor
-            #     for interceptor in self.lifecycle.initialized_interceptors
-            #     if isinstance(interceptor, WebSocketInterceptor)
-            # ]
+                for controller_t in self.lifecycle.app.controllers:
+                    controller = RestController.get_controller(controller_t)
 
-            # for interceptor in websocket_interceptors:
-            #     router = interceptor.get_ws_router(
-            #         self.lifecycle.app, self.lifecycle.container, self.uow_provider
-            #     )
+                    if controller is None:
+                        continue
 
-            #     api.include_router(router)
+                    instance: Any = self.lifecycle.container.get_by_type(controller_t)
 
-            for controller_t in self.lifecycle.app.controllers:
-                controller = RestController.get_controller(controller_t)
+                    router = controller.get_router_factory()(self.lifecycle, instance)
 
-                if controller is None:
-                    continue
+                    api.include_router(router)
 
-                instance: Any = self.lifecycle.container.get_by_type(controller_t)
+                    for middleware in self.http_app.middlewares:
+                        middleware_instance = self.lifecycle.container.get_by_type(
+                            middleware
+                        )
+                        api.router.dependencies.append(
+                            Depends(middleware_instance.intercept)
+                        )
 
-                # dependencies: list[DependsCls] = []
-                # for middleware in controller.middlewares:
-                #     middleware_instance = self.lifecycle.container.get_by_type(
-                #         middleware
-                #     )
-                #     dependencies.append(Depends(middleware_instance.intercept))
-
-                router = controller.get_router_factory()(self.lifecycle, instance)
-
-                api.include_router(router)
-
-                for middleware in self.http_app.middlewares:
-                    middleware_instance = self.lifecycle.container.get_by_type(
-                        middleware
-                    )
-                    api.router.dependencies.append(
-                        Depends(middleware_instance.intercept)
-                    )
-
-            yield
+                yield
 
 
 class HttpShutdownState(ShutdownState):

{jararaca-0.3.12a22 → jararaca-0.3.14}/src/jararaca/scheduler/beat_worker.py

@@ -31,7 +31,7 @@ from jararaca.broker_backend.mapper import get_message_broker_backend_from_url
 from jararaca.core.uow import UnitOfWorkContextProvider
 from jararaca.di import Container
 from jararaca.lifecycle import AppLifecycle
-from jararaca.microservice import Microservice
+from jararaca.microservice import Microservice, providing_app_type
 from jararaca.scheduler.decorators import (
     ScheduledAction,
     ScheduledActionData,
@@ -572,22 +572,23 @@ class BeatWorker:
         Declares the scheduled actions and starts the scheduler.
         This is the main entry point for the scheduler.
         """
-        async with self.lifecycle():
+        with providing_app_type("beat"):
+            async with self.lifecycle():
 
-            scheduled_actions = _extract_scheduled_actions(
-                self.app, self.container, self.scheduler_names
-            )
+                scheduled_actions = _extract_scheduled_actions(
+                    self.app, self.container, self.scheduler_names
+                )
 
-            # Initialize and wait for connection to be established
-            logger.info("Initializing broker connection...")
-            await self.broker.initialize(scheduled_actions)
+                # Initialize and wait for connection to be established
+                logger.info("Initializing broker connection...")
+                await self.broker.initialize(scheduled_actions)
 
-            # Wait for connection to be healthy before starting scheduler
-            logger.info("Waiting for connection to be established...")
-            await self._wait_for_broker_connection()
+                # Wait for connection to be healthy before starting scheduler
+                logger.info("Waiting for connection to be established...")
+                await self._wait_for_broker_connection()
 
-            logger.info("Connection established, starting scheduler...")
-            await self.run_scheduled_actions(scheduled_actions)
+                logger.info("Connection established, starting scheduler...")
+                await self.run_scheduled_actions(scheduled_actions)
 
     async def run_scheduled_actions(
         self, scheduled_actions: list[ScheduledActionData]

{jararaca-0.3.12a22 → jararaca-0.3.14}/src/jararaca/tools/typescript/interface_parser.py

@@ -26,7 +26,7 @@ from uuid import UUID
 from fastapi import Request, Response, UploadFile
 from fastapi.params import Body, Cookie, Depends, Form, Header, Path, Query
 from fastapi.security.http import HTTPBase
-from pydantic import BaseModel, PlainValidator
+from pydantic import BaseModel, PlainValidator, RootModel
 from pydantic_core import PydanticUndefined
 
 from jararaca.microservice import Microservice
@@ -314,6 +314,26 @@ def get_field_type_for_ts(field_type: Any, context_suffix: str = "") -> Any:
         field_type: The Python type to convert
         context_suffix: Suffix for split models (e.g., "Input", "Output")
     """
+    # Handle RootModel types - use the wrapped type directly
+    if inspect.isclass(field_type) and issubclass(field_type, RootModel):
+        # For concrete RootModel subclasses, get the wrapped type from annotations
+        if (
+            hasattr(field_type, "__annotations__")
+            and "root" in field_type.__annotations__
+        ):
+            wrapped_type = field_type.__annotations__["root"]
+            return get_field_type_for_ts(wrapped_type, context_suffix)
+
+        # For parameterized RootModel[T] types, get the type from pydantic metadata
+        if hasattr(field_type, "__pydantic_generic_metadata__"):
+            metadata = field_type.__pydantic_generic_metadata__
+            if metadata.get("origin") is RootModel and metadata.get("args"):
+                # Get the first (and only) type argument
+                wrapped_type = metadata["args"][0]
+                return get_field_type_for_ts(wrapped_type, context_suffix)
+
+        return "unknown"
+
     if field_type is Response:
         return "unknown"
     if field_type is Any: