fix route introspection for fastapi 0.137

Author: deeleeramone

cli/uv.lock

@@ -6,6 +6,7 @@
 
 from openbb_core.api.exception_handlers import ExceptionHandlers
 from openbb_core.app.model.abstract.error import OpenBBError
+from openbb_core.app.route_iter import iter_included_routers
 from openbb_core.app.router import RouterLoader
 from openbb_core.provider.utils.errors import EmptyDataError, UnauthorizedError
 
@@ -19,6 +20,7 @@ def add_routers(app: FastAPI, routers: list[APIRouter | None], prefix: str):
         for router in routers:
             if router:
                 app.include_router(router=router, prefix=prefix)
+        AppLoader.deduplicate_router_event_handlers(app)
 
     @staticmethod
     def add_openapi_tags(app: FastAPI):
@@ -36,9 +38,20 @@ def add_openapi_tags(app: FastAPI):
     @staticmethod
     def add_exception_handlers(app: FastAPI):
         """Add exception handlers."""
-        app.exception_handlers[Exception] = ExceptionHandlers.exception
-        app.exception_handlers[ValidationError] = ExceptionHandlers.validation
-        app.exception_handlers[ResponseValidationError] = ExceptionHandlers.validation
-        app.exception_handlers[OpenBBError] = ExceptionHandlers.openbb
-        app.exception_handlers[EmptyDataError] = ExceptionHandlers.empty_data
-        app.exception_handlers[UnauthorizedError] = ExceptionHandlers.unauthorized
+        app.add_exception_handler(Exception, ExceptionHandlers.exception)
+        app.add_exception_handler(ValidationError, ExceptionHandlers.validation)  # ty: ignore[invalid-argument-type]
+        app.add_exception_handler(ResponseValidationError, ExceptionHandlers.validation)  # ty: ignore[invalid-argument-type]
+        app.add_exception_handler(OpenBBError, ExceptionHandlers.openbb)  # ty: ignore[invalid-argument-type]
+        app.add_exception_handler(EmptyDataError, ExceptionHandlers.empty_data)  # ty: ignore[invalid-argument-type]
+        app.add_exception_handler(UnauthorizedError, ExceptionHandlers.unauthorized)  # ty: ignore[invalid-argument-type]
+
+    @staticmethod
+    def deduplicate_router_event_handlers(app: FastAPI) -> None:
+        """Clear startup/shutdown handlers on included routers after assembly."""
+        for included in iter_included_routers(app.router):
+            on_startup = getattr(included, "on_startup", None)
+            on_shutdown = getattr(included, "on_shutdown", None)
+            if isinstance(on_startup, list):
+                on_startup.clear()
+            if isinstance(on_shutdown, list):
+                on_shutdown.clear()

openbb_platform/core/openbb_core/api/app_loader.py

@@ -65,6 +65,7 @@ async def lifespan(_: FastAPI):
         for s in system.api_settings.servers
     ],
     lifespan=lifespan,
+    strict_content_type=False,
 )
 app.add_middleware(
     CORSMiddleware,

openbb_platform/core/openbb_core/api/rest_api.py

@@ -19,6 +19,7 @@
 from openbb_core.app.model.command_context import CommandContext
 from openbb_core.app.model.obbject import OBBject
 from openbb_core.app.model.user_settings import UserSettings
+from openbb_core.app.route_iter import iter_api_routes
 from openbb_core.app.router import RouterLoader
 from openbb_core.app.service.auth_service import AuthService
 from openbb_core.app.service.system_service import SystemService
@@ -353,9 +354,16 @@ async def wrapper(  # noqa: PLR0912
 def add_command_map(command_runner: CommandRunner, api_router: APIRouter) -> None:
     """Add command map to the API router."""
     plugins_router = RouterLoader.from_extensions()
-
-    for route in plugins_router.api_router.routes:
-        route.endpoint = build_api_wrapper(command_runner=command_runner, route=route)  # type: ignore # noqa
+    for effective in iter_api_routes(plugins_router.api_router):
+        leaf = getattr(effective, "original_route", effective)
+        if not isinstance(leaf, APIRoute):
+            continue
+        original_leaf_path = leaf.path
+        leaf.path = effective.path
+        try:
+            leaf.endpoint = build_api_wrapper(command_runner=command_runner, route=leaf)
+        finally:
+            leaf.path = original_leaf_path
     api_router.include_router(router=plugins_router.api_router)
 
 

openbb_platform/core/openbb_core/api/router/commands.py

@@ -0,0 +1,35 @@
+"""Route iteration helpers."""
+
+from collections.abc import Iterator
+from typing import Any
+
+from fastapi.routing import APIRoute
+
+_IncludedRouter: type | None = None
+try:  # noqa: SIM105
+    from fastapi.routing import (
+        _IncludedRouter,  # type: ignore[attr-defined,no-redef]
+    )
+except ImportError:  # pragma: no cover
+    pass
+
+
+def iter_api_routes(router: Any) -> Iterator:
+    """Yield prefix-resolved route descriptors from a router or app."""
+    if not hasattr(router, "routes"):
+        return
+    for route in router.routes:
+        if _IncludedRouter is not None and isinstance(route, _IncludedRouter):
+            yield from route.effective_route_contexts()
+        elif isinstance(route, APIRoute):
+            yield route
+
+
+def iter_included_routers(router: Any) -> Iterator:
+    """Yield every original ``APIRouter`` reachable through ``include_router``."""
+    if not hasattr(router, "routes") or _IncludedRouter is None:
+        return
+    for route in router.routes:
+        if isinstance(route, _IncludedRouter):
+            yield route.original_router
+            yield from iter_included_routers(route.original_router)

openbb_platform/core/openbb_core/app/route_iter.py

@@ -29,6 +29,7 @@
     ProviderInterface,
     StandardParams,
 )
+from openbb_core.app.route_iter import iter_api_routes
 from openbb_core.env import Env
 
 P = ParamSpec("P")
@@ -430,7 +431,9 @@ def get_command_map(
     ) -> dict[str, Callable]:
         """Get command map."""
         api_router = router.api_router
-        command_map = {route.path: route.endpoint for route in api_router.routes}  # type: ignore
+        command_map = {
+            route.path: route.endpoint for route in iter_api_routes(api_router)
+        }
         return command_map
 
     @staticmethod
@@ -443,7 +446,7 @@ def get_provider_coverage(
         mapping = ProviderInterface().map
 
         coverage_map: dict[Any, Any] = {}
-        for route in api_router.routes:
+        for route in iter_api_routes(api_router):
             openapi_extra = getattr(route, "openapi_extra", None)
             if openapi_extra:
                 model = openapi_extra.get("model", None)
@@ -458,7 +461,7 @@ def get_provider_coverage(
                             rp = (
                                 route.path
                                 if sep is None
-                                else route.path.replace("/", sep)  # type: ignore
+                                else route.path.replace("/", sep)
                             )
                             coverage_map[provider].append(rp)
 
@@ -474,7 +477,7 @@ def get_command_coverage(
         mapping = ProviderInterface().map
 
         coverage_map: dict[Any, Any] = {}
-        for route in api_router.routes:
+        for route in iter_api_routes(api_router):
             openapi_extra = getattr(route, "openapi_extra")
             if openapi_extra:
                 model = openapi_extra.get("model", None)
@@ -484,7 +487,7 @@ def get_command_coverage(
                         providers.remove("openbb")
 
                     if hasattr(route, "path"):
-                        rp = route.path if sep is None else route.path.replace("/", sep)  # type: ignore
+                        rp = route.path if sep is None else route.path.replace("/", sep)
                         if route.path not in coverage_map:
                             coverage_map[rp] = []
                         coverage_map[rp] = providers
@@ -496,12 +499,12 @@ def get_commands_model(router: Router, sep: str | None = None) -> dict[str, str]
         api_router = router.api_router
 
         coverage_map: dict[Any, Any] = {}
-        for route in api_router.routes:
+        for route in iter_api_routes(api_router):
             openapi_extra = getattr(route, "openapi_extra")
             if openapi_extra:
                 model = openapi_extra.get("model", None)
                 if model and hasattr(route, "path"):
-                    rp = route.path if sep is None else route.path.replace("/", sep)  # type: ignore
+                    rp = route.path if sep is None else route.path.replace("/", sep)
                     if route.path not in coverage_map:
                         coverage_map[rp] = []
                     coverage_map[rp] = model

openbb_platform/core/openbb_core/app/router.py

@@ -6,9 +6,9 @@
     TypeVar,
 )
 
-from fastapi.routing import APIRoute
 from starlette.routing import BaseRoute
 
+from openbb_core.app.route_iter import iter_api_routes
 from openbb_core.app.router import RouterLoader
 
 if TYPE_CHECKING:
@@ -83,41 +83,16 @@ def get_router_dependencies(path: str) -> list:
     def build_route_map() -> dict[str, BaseRoute]:
         """Build the route map."""
         router = RouterLoader.from_extensions()
-        route_map = {
-            route.path: route
-            for route in router.api_router.routes
-            if isinstance(route, APIRoute)
-            and "." not in str(route.path)
-            and getattr(route, "include_in_schema", True)
-        }
-
-        # Also include routes directly registered on _api_router instances
-        # We need to traverse the router tree to find all _api_router instances
-        def collect_api_router_routes(router_obj, collected_routes):
-            """Recursively collect routes from _api_router instances."""
-            if hasattr(router_obj, "_api_router"):
-                for inner_route in router_obj._api_router.routes:
-                    if (
-                        isinstance(inner_route, APIRoute)
-                        and getattr(inner_route, "include_in_schema", True)
-                        and (inner_route.path not in collected_routes)
-                    ):
-                        collected_routes[inner_route.path] = inner_route
-
-            # Check if this router has sub-routers
-            if hasattr(router_obj, "api_router") and hasattr(
-                router_obj.api_router, "routes"
-            ):
-                for route in router_obj.api_router.routes:
-                    if not isinstance(route, APIRoute):
-                        continue
-                    endpoint = getattr(route, "endpoint", None)
-                    if endpoint and hasattr(endpoint, "__self__"):
-                        collect_api_router_routes(endpoint.__self__, collected_routes)
-
-        collect_api_router_routes(router, route_map)
-
-        return route_map  # type: ignore
+        route_map: dict[str, BaseRoute] = {}
+        for route in iter_api_routes(router.api_router):
+            path = getattr(route, "path", None)
+            if path is None:
+                continue
+            if not getattr(route, "include_in_schema", True):
+                continue
+            if path not in route_map:
+                route_map[path] = route  # type: ignore[assignment]
+        return route_map
 
     @staticmethod
     def build_path_list(route_map: dict[str, BaseRoute]) -> list[str]:

openbb_platform/core/openbb_core/app/static/package_builder/path_handler.py

@@ -19,6 +19,7 @@
 
 from openbb_core.api import rest_api
 from openbb_core.api.rest_api import app, system
+from openbb_core.app.route_iter import iter_api_routes
 
 
 def test_openapi_schema_metadata_matches_system_settings():
@@ -71,7 +72,7 @@ def test_router_inclusion_invariant_commands_imply_coverage():
     The invariant we test: if there exists any command route, coverage
     routes must exist. This catches accidental removal of the conditional.
     """
-    paths = {getattr(r, "path", None) for r in app.routes}
+    paths = {getattr(r, "path", None) for r in iter_api_routes(app)}
     prefix = system.api_settings.prefix
 
     coverage_paths = {

openbb_platform/core/tests/api/test_rest_api.py

@@ -432,5 +432,10 @@ async def wrapped():
     api_router = APIRouter()
     add_command_map(MagicMock(spec=CommandRunner), api_router)
 
+    from openbb_core.app.route_iter import iter_api_routes
+
     assert plugins_api_router.routes[0].endpoint is wrapped
-    assert any(getattr(route, "path", None) == "/plugin" for route in api_router.routes)
+    assert any(
+        getattr(route, "path", None) == "/plugin"
+        for route in iter_api_routes(api_router)
+    )

openbb_platform/core/tests/api/test_router/test_commands_helpers.py

@@ -1457,8 +1457,13 @@ def endpoint(symbol: str = "AAPL"):
     monkeypatch.setattr(
         MethodDefinition, "is_deprecated_function", staticmethod(lambda p: False)
     )
-    monkeypatch.setattr(
-        md.inspect, "getsource", lambda _f: (_ for _ in ()).throw(TypeError("x"))
-    )
+    real_getsource = md.inspect.getsource
+
+    def _patched_getsource(obj):
+        if obj is endpoint:
+            raise TypeError("x")
+        return real_getsource(obj)
+
+    monkeypatch.setattr(md.inspect, "getsource", _patched_getsource)
     code = MethodDefinition.build_command_method("/x/y", endpoint)
     assert "def y" in code