fastapi-voyager 0.15.5__py3-none-any.whl → 0.16.0a1__py3-none-any.whl

fastapi_voyager/introspectors/django_ninja.py

@@ -0,0 +1,114 @@
+"""
+Django Ninja implementation of the AppIntrospector interface.
+
+This module provides the adapter that allows fastapi-voyager to work with Django Ninja applications.
+"""
+from collections.abc import Iterator
+
+from fastapi_voyager.introspectors.base import AppIntrospector, RouteInfo
+
+
+class DjangoNinjaIntrospector(AppIntrospector):
+    """
+    Django Ninja-specific implementation of AppIntrospector.
+
+    This class extracts route information from Django Ninja's internal structure
+    and converts it to the framework-agnostic RouteInfo format.
+    """
+
+    def __init__(self, ninja_api, swagger_url: str | None = None):
+        """
+        Initialize the Django Ninja introspector.
+
+        Args:
+            ninja_api: The Django Ninja API instance
+            swagger_url: Optional custom URL to Swagger documentation
+        """
+        self.api = ninja_api
+        self.swagger_url = swagger_url or "/api/docs"
+
+    def get_routes(self) -> Iterator[RouteInfo]:
+        """
+        Iterate over all API routes in the Django Ninja application.
+
+        Yields:
+            RouteInfo: Standardized route information for each API route
+        """
+        # Access the internal router structure
+        if not hasattr(self.api, "default_router"):
+            return
+
+        router = self.api.default_router
+
+        # Iterate through all path operations registered in the router
+        if not hasattr(router, "path_operations"):
+            return
+
+        for path, path_view in router.path_operations.items():
+            # path_view is a PathView object with a list of operations
+            if not hasattr(path_view, "operations"):
+                continue
+
+            for operation in path_view.operations:
+                try:
+                    yield RouteInfo(
+                        id=self._get_route_id(operation),
+                        name=operation.view_func.__name__,
+                        module=operation.view_func.__module__,
+                        operation_id=operation.operation_id or operation.view_func.__name__,
+                        tags=operation.tags or [],
+                        endpoint=operation.view_func,
+                        response_model=self._get_response_model(operation),
+                        extra={
+                            "methods": operation.methods,  # This is a list
+                            "path": path,
+                        },
+                    )
+                except (AttributeError, TypeError):
+                    # Skip routes that don't have the expected structure
+                    continue
+
+    def get_swagger_url(self) -> str | None:
+        """
+        Get the URL to the Swagger UI documentation.
+
+        Returns:
+            The URL path to Swagger UI
+        """
+        return self.swagger_url
+
+    def _get_route_id(self, operation) -> str:
+        """
+        Generate a unique identifier for the route.
+
+        Uses the full class path of the view function.
+
+        Args:
+            operation: The Django Ninja operation object
+
+        Returns:
+            A unique identifier string
+        """
+        # Import here to avoid circular dependency
+        from fastapi_voyager.type_helper import full_class_name
+        return full_class_name(operation.view_func)
+
+    def _get_response_model(self, operation) -> type:
+        """
+        Extract the response model from the operation.
+
+        Django Ninja infers response model from function's return type annotation.
+
+        Args:
+            operation: The Django Ninja operation object
+
+        Returns:
+            The response model class, or type(None) if not found
+        """
+        # Django Ninja uses type hints for response models
+        # The response_models field is always NOT_SET_TYPE, so we only check __annotations__
+        if hasattr(operation.view_func, "__annotations__") and "return" in operation.view_func.__annotations__:
+            return operation.view_func.__annotations__["return"]
+
+        # No response model found
+        return type(None)  # type: ignore

fastapi_voyager/introspectors/fastapi.py

@@ -0,0 +1,83 @@
+"""
+FastAPI implementation of the AppIntrospector interface.
+
+This module provides the adapter that allows fastapi-voyager to work with FastAPI applications.
+"""
+from collections.abc import Iterator
+
+from fastapi import FastAPI, routing
+
+from fastapi_voyager.introspectors.base import AppIntrospector, RouteInfo
+
+
+class FastAPIIntrospector(AppIntrospector):
+    """
+    FastAPI-specific implementation of AppIntrospector.
+
+    This class extracts route information from FastAPI's internal route structure
+    and converts it to the framework-agnostic RouteInfo format.
+    """
+
+    def __init__(self, app: FastAPI, swagger_url: str | None = None):
+        """
+        Initialize the FastAPI introspector.
+
+        Args:
+            app: The FastAPI application instance
+            swagger_url: Optional custom URL to Swagger documentation
+        """
+        self.app = app
+        self.swagger_url = swagger_url or "/docs"
+
+    def get_routes(self) -> Iterator[RouteInfo]:
+        """
+        Iterate over all API routes in the FastAPI application.
+
+        Yields:
+            RouteInfo: Standardized route information for each API route
+        """
+        for route in self.app.routes:
+            # Only process APIRoute instances (not static files, etc.)
+            if isinstance(route, routing.APIRoute):
+                # Extract tags from the route
+                tags = getattr(route, 'tags', None) or []
+
+                yield RouteInfo(
+                    id=self._get_route_id(route),
+                    name=route.endpoint.__name__,
+                    module=route.endpoint.__module__,
+                    operation_id=route.operation_id,
+                    tags=tags,
+                    endpoint=route.endpoint,
+                    response_model=route.response_model,
+                    extra={
+                        'unique_id': route.unique_id,
+                        'methods': route.methods,
+                        'path': route.path,
+                    }
+                )
+
+    def get_swagger_url(self) -> str | None:
+        """
+        Get the URL to the Swagger UI documentation.
+
+        Returns:
+            The URL path to Swagger UI
+        """
+        return self.swagger_url
+
+    def _get_route_id(self, route: routing.APIRoute) -> str:
+        """
+        Generate a unique identifier for the route.
+
+        Uses the full class path of the endpoint function.
+
+        Args:
+            route: The FastAPI route object
+
+        Returns:
+            A unique identifier string
+        """
+        # Import here to avoid circular dependency
+        from fastapi_voyager.type_helper import full_class_name
+        return full_class_name(route.endpoint)

fastapi_voyager/introspectors/litestar.py

@@ -0,0 +1,166 @@
+"""
+Litestar implementation of the AppIntrospector interface.
+
+This module provides the adapter that allows fastapi-voyager to work with Litestar applications.
+"""
+from collections.abc import Iterator
+
+from fastapi_voyager.introspectors.base import AppIntrospector, RouteInfo
+
+
+class LitestarIntrospector(AppIntrospector):
+    """
+    Litestar-specific implementation of AppIntrospector.
+
+    This class extracts route information from Litestar's internal structure
+    and converts it to the framework-agnostic RouteInfo format.
+    """
+
+    def __init__(self, app, swagger_url: str | None = None):
+        """
+        Initialize the Litestar introspector.
+
+        Args:
+            app: The Litestar application instance
+            swagger_url: Optional custom URL to Swagger/OpenAPI documentation
+        """
+        self.app = app
+        self.swagger_url = swagger_url or "/schema/swagger"
+
+    def get_routes(self) -> Iterator[RouteInfo]:
+        """
+        Iterate over all routes in the Litestar application.
+
+        Yields:
+            RouteInfo: Standardized route information for each route
+        """
+        for route in self.app.routes:
+            try:
+                # Skip routes without path or methods
+                if not hasattr(route, "path") or not hasattr(route, "methods"):
+                    continue
+
+                # Skip Litestar's auto-generated schema routes
+                if hasattr(route, "path") and route.path.startswith("/schema"):
+                    continue
+
+                # Get the handler function from route_handlers
+                handler = None
+                handler_obj = None
+                if hasattr(route, "route_handlers") and route.route_handlers:
+                    # Find the GET handler (or any non-OPTIONS handler)
+                    for route_handler in route.route_handlers:
+                        if hasattr(route_handler, "fn") and hasattr(route_handler.fn, "__name__"):
+                            # Store the route handler object for tags
+                            if hasattr(route_handler, "http_methods") and "GET" in route_handler.http_methods:
+                                handler_obj = route_handler
+                            handler = route_handler.fn
+                            if handler_obj:
+                                break
+
+                if not handler:
+                    continue
+
+                # Skip handlers with names starting with _ (internal/private)
+                if hasattr(handler, "__name__") and handler.__name__.startswith("_"):
+                    continue
+
+                # Extract tags from the route handler object
+                tags = []
+                if handler_obj and hasattr(handler_obj, "tags") and handler_obj.tags:
+                    tags = list(handler_obj.tags)
+
+                # Get return type from handler's annotations
+                return_model = type(None)
+                if hasattr(handler, "__annotations__") and "return" in handler.__annotations__:
+                    return_model = handler.__annotations__["return"]
+
+                yield RouteInfo(
+                    id=self._get_route_id(handler),
+                    name=handler.__name__,
+                    module=handler.__module__,
+                    operation_id=self._get_operation_id(route, handler),
+                    tags=tags,
+                    endpoint=handler,
+                    response_model=return_model,
+                    extra={
+                        "methods": list(route.methods) if hasattr(route, "methods") else [],
+                        "path": route.path,
+                    },
+                )
+            except (AttributeError, TypeError):
+                # Skip routes that don't have the expected structure
+                continue
+
+    def get_swagger_url(self) -> str | None:
+        """
+        Get the URL to the Swagger/OpenAPI documentation.
+
+        Returns:
+            The URL path to Swagger UI
+        """
+        return self.swagger_url
+
+    def _get_route_id(self, handler) -> str:
+        """
+        Generate a unique identifier for the route.
+
+        Uses the full module path of the handler function.
+
+        Args:
+            handler: The route handler function
+
+        Returns:
+            A unique identifier string
+        """
+        # Import here to avoid circular dependency
+        from fastapi_voyager.type_helper import full_class_name
+        return full_class_name(handler)
+
+    def _get_operation_id(self, route, handler) -> str:
+        """
+        Extract or generate the operation ID for the route.
+
+        Args:
+            route: The Litestar route object
+            handler: The handler function
+
+        Returns:
+            An operation ID string
+        """
+        # Litestar might not have operation_id, so we generate one
+        if hasattr(route, "operation_id"):
+            return route.operation_id
+        # Fallback to using the handler function name
+        if hasattr(handler, "__name__"):
+            return handler.__name__
+        # Fallback to using the path
+        if hasattr(route, "path"):
+            return route.path
+        return ""
+
+    def _get_response_model(self, route) -> type:
+        """
+        Extract the response model from the route.
+
+        Args:
+            route: The Litestar route object
+
+        Returns:
+            The response model class
+        """
+        # Try to get response model from route
+        if hasattr(route, "responses"):
+            responses = route.responses
+            if responses and "200" in responses:
+                response_200 = responses["200"]
+                if hasattr(response_200, "model"):
+                    return response_200.model
+
+        # Fallback: check if handler has return annotation
+        handler = route.handler if hasattr(route, "handler") else None
+        if handler and hasattr(handler, "__annotations__") and "return" in handler.__annotations__:
+            return handler.__annotations__["return"]
+
+        # Return None if no response model found
+        return type(None)  # type: ignore

fastapi_voyager/pydantic_resolve_util.py

@@ -1,10 +1,12 @@
 import inspect
+
+import pydantic_resolve.constant as const
 from pydantic import BaseModel
 from pydantic.fields import FieldInfo
+from pydantic_resolve.utils.collector import ICollector, SendToInfo
 from pydantic_resolve.utils.er_diagram import LoaderInfo
-import pydantic_resolve.constant as const
 from pydantic_resolve.utils.expose import ExposeInfo
-from pydantic_resolve.utils.collector import SendToInfo, ICollector
+
 
 def analysis_pydantic_resolve_fields(schema: type[BaseModel], field: str):
     """

fastapi_voyager/render.py

@@ -10,8 +10,8 @@ from fastapi_voyager.module import build_module_route_tree, build_module_schema_
 from fastapi_voyager.render_style import RenderConfig
 from fastapi_voyager.type import (
     PK,
-    FieldType,
     FieldInfo,
+    FieldType,
     Link,
     ModuleNode,
     ModuleRoute,
@@ -361,7 +361,7 @@ class Renderer:
 
             if cluster_color:
                 pen_style = f'pencolor = "{cluster_color}"'
-                pen_style += '\n' + f'penwidth = 3' if color else ''
+                pen_style += '\n' + 'penwidth = 3' if color else ''
             else:
                 pen_style = 'pencolor="#ccc"'
 

fastapi_voyager/render_style.py

@@ -2,7 +2,6 @@
 Style constants and configuration for rendering DOT graphs and HTML tables.
 """
 from dataclasses import dataclass, field
-from typing import Literal
 
 
 @dataclass