apisec-code-bolt 0.1.0__py3-none-any.whl

apisec_code_bolt/parsing/python/language_services.py

@@ -0,0 +1,487 @@
+"""
+Python-specific implementation of LanguageServices.
+
+This module provides the Python implementations of the abstract service
+protocols defined in parsing/services.py. It adapts the existing Python
+parsing infrastructure to the language-agnostic interfaces.
+
+DESIGN:
+- Implements LanguageServices for Python
+- Wraps existing components (CrossFileResolver, etc.) in protocol adapters
+- Provides framework-specific services (FastAPI router registry, etc.)
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from ..services import (
+    AnalysisContext,
+    LanguageServices,
+    ResolvedConstant,
+    ResolvedField,
+    ResolvedPath,
+    ResolvedType,
+    RouterInfo,
+    TypeResolver,
+)
+from ..services import (
+    ConstantResolver as ConstantResolverProtocol,
+)
+from ..services import (
+    PathResolver as PathResolverProtocol,
+)
+
+if TYPE_CHECKING:
+    from ..base import ParsedFile
+
+
+# =============================================================================
+# Protocol Adapters
+# =============================================================================
+
+# These adapters wrap existing Python components to implement the abstract protocols
+
+
+class PythonTypeResolverAdapter:
+    """
+    Adapter that wraps CrossFileResolver to implement TypeResolver protocol.
+    """
+
+    def __init__(self, cross_file_resolver):
+        """
+        Args:
+            cross_file_resolver: Python CrossFileResolver instance
+        """
+        self._resolver = cross_file_resolver
+
+    def resolve_type(
+        self,
+        name: str,
+        in_file: Path | None = None,
+    ) -> ResolvedType | None:
+        """Resolve a type reference."""
+        symbol = self._resolver.resolve_symbol(name, in_file)
+        if not symbol:
+            return None
+
+        return ResolvedType(
+            name=symbol.name,
+            qualified_name=symbol.qualified_name,
+            file_path=symbol.file_path,
+            is_class=symbol.is_class,
+            is_model=symbol.is_pydantic_model,
+            is_enum=symbol.is_enum if hasattr(symbol, "is_enum") else False,
+            is_external=symbol.is_external,
+            external_package=symbol.external_package,
+            base_classes=list(symbol.bases),
+            all_ancestors=list(symbol.all_bases) if hasattr(symbol, "all_bases") else [],
+            mro=list(symbol.mro) if hasattr(symbol, "mro") else [],
+            definition=symbol.definition,
+        )
+
+    def is_model_type(
+        self,
+        name: str,
+        in_file: Path | None = None,
+    ) -> bool:
+        """Check if type is a Pydantic model."""
+        return self._resolver.is_pydantic_model(name, in_file)
+
+    def get_model_fields(
+        self,
+        model_name: str,
+        in_file: Path | None = None,
+        include_inherited: bool = True,
+    ) -> list[ResolvedField]:
+        """Get fields for a model."""
+        raw_fields = self._resolver.get_model_fields(model_name, in_file, include_inherited)
+
+        return [
+            ResolvedField(
+                name=f.get("name", ""),
+                type_annotation=f.get("type_annotation"),
+                default_value=f.get("default_value"),
+                is_required=f.get("is_required", True),
+                nested_type_name=f.get("nested_model_name"),
+                alias=f.get("alias"),
+                description=f.get("description"),
+                constraints=f.get("constraints", {}),
+                defined_in_class=f.get("defined_in"),
+            )
+            for f in raw_fields
+        ]
+
+    def is_subclass_of(
+        self,
+        class_name: str,
+        base_name: str,
+        in_file: Path | None = None,
+    ) -> bool:
+        """Check inheritance relationship."""
+        symbol = self._resolver.resolve_symbol(class_name, in_file)
+        if not symbol:
+            return False
+
+        # Check direct bases and all ancestors
+        if base_name in symbol.bases:
+            return True
+        return bool(hasattr(symbol, "all_bases") and base_name in symbol.all_bases)
+
+    def get_all_models(self) -> dict[str, ResolvedType]:
+        """Get all Pydantic models."""
+        raw_models = self._resolver.get_all_pydantic_models()
+        result = {}
+
+        for qname, symbol in raw_models.items():
+            # symbol may be ParsedClass (from get_all_pydantic_models) or ResolvedSymbol
+            file_path = getattr(symbol, "file_path", None) or (
+                symbol.location.file if hasattr(symbol, "location") and symbol.location else None
+            )
+            bases = getattr(symbol, "bases", None) or getattr(symbol, "base_classes", [])
+            definition = getattr(symbol, "definition", symbol)  # ParsedClass is its own definition
+            result[qname] = ResolvedType(
+                name=symbol.name,
+                qualified_name=symbol.qualified_name.full
+                if hasattr(symbol.qualified_name, "full")
+                else str(symbol.qualified_name),
+                file_path=file_path,
+                is_class=True,
+                is_model=True,
+                base_classes=list(bases),
+                definition=definition,
+            )
+
+        return result
+
+
+class PythonConstantResolverAdapter:
+    """
+    Adapter that wraps Python ConstantResolver to implement the protocol.
+    """
+
+    def __init__(self, constant_resolver):
+        """
+        Args:
+            constant_resolver: Python ConstantResolver instance
+        """
+        self._resolver = constant_resolver
+
+    def resolve(
+        self,
+        expression: str,
+        in_file: Path | None = None,
+    ) -> ResolvedConstant | None:
+        """Resolve a constant expression."""
+        result = self._resolver.resolve(expression, in_file)
+        if not result:
+            return None
+
+        return ResolvedConstant(
+            name=result.name,
+            value=result.value,
+            source_file=result.source_file,
+            source_line=result.source_line,
+            source_type=result.source_type,
+            is_default=result.is_default,
+            override_sources=result.override_sources,
+            confidence=result.confidence,
+        )
+
+    def resolve_value(
+        self,
+        expression: str,
+        in_file: Path | None = None,
+    ) -> str | None:
+        """Get just the value."""
+        return self._resolver.resolve_value(expression, in_file)
+
+    def get_all_constants(self) -> dict[str, str]:
+        """Get all constants."""
+        return self._resolver.get_all_constants()
+
+
+class PythonPathResolverAdapter:
+    """
+    Adapter that wraps Python PathResolver to implement the protocol.
+    """
+
+    def __init__(self, path_resolver):
+        """
+        Args:
+            path_resolver: Python PathResolver instance
+        """
+        self._resolver = path_resolver
+
+    def set_constant_resolver(self, resolver) -> None:
+        """Set constant resolver for path variable resolution."""
+        # Unwrap if it's an adapter
+        if isinstance(resolver, PythonConstantResolverAdapter):
+            self._resolver.set_constant_resolver(resolver._resolver)
+        elif hasattr(self._resolver, "set_constant_resolver"):
+            self._resolver.set_constant_resolver(resolver)
+
+    def resolve(
+        self,
+        path_expression: str,
+        file_path: Path,
+        additional_context: dict[str, str] | None = None,
+    ) -> ResolvedPath:
+        """Resolve a path expression."""
+        result = self._resolver.resolve(path_expression, file_path, additional_context)
+
+        return ResolvedPath(
+            path=result.path,
+            confidence=result.resolution_confidence,
+            is_fully_resolved=len(result.unresolved_vars) == 0,
+            unresolved_vars=result.unresolved_vars,
+            notes=result.notes if hasattr(result, "notes") else [],
+        )
+
+    def get_all_constants(self) -> dict[str, str]:
+        """Get all path constants."""
+        return self._resolver.get_all_constants()
+
+
+class PythonRouterRegistryAdapter:
+    """
+    Adapter that wraps Python RouterRegistry to implement the protocol.
+    """
+
+    def __init__(self, router_registry):
+        """
+        Args:
+            router_registry: Python RouterRegistry instance (FastAPI-specific)
+        """
+        self._registry = router_registry
+
+    def set_constant_resolver(self, resolver) -> None:
+        """Set constant resolver for prefix resolution."""
+        if isinstance(resolver, PythonConstantResolverAdapter):
+            self._registry.set_constant_resolver(resolver._resolver)
+        elif hasattr(self._registry, "set_constant_resolver"):
+            self._registry.set_constant_resolver(resolver)
+
+    def resolve_path(
+        self,
+        router_var: str,
+        route_path: str,
+        file_path: Path,
+    ) -> str:
+        """Resolve full path with prefixes."""
+        return self._registry.resolve_path(router_var, route_path, file_path)
+
+    def get_router(self, name: str, file_path: Path) -> RouterInfo | None:
+        """Get router info."""
+        routers = self._registry.get_all_routers()
+
+        # Try qualified lookup
+        for qname, router in routers.items():
+            if router.name == name and router.file_path == file_path:
+                return RouterInfo(
+                    name=router.name,
+                    qualified_name=qname,
+                    file_path=router.file_path,
+                    router_type=router.router_type,
+                    prefix=router.prefix,
+                    tags=router.tags,
+                )
+
+        return None
+
+    def get_all_routers(self) -> dict[str, RouterInfo]:
+        """Get all routers."""
+        result = {}
+        for qname, router in self._registry.get_all_routers().items():
+            result[qname] = RouterInfo(
+                name=router.name,
+                qualified_name=qname,
+                file_path=router.file_path,
+                router_type=router.router_type,
+                prefix=router.prefix,
+                tags=router.tags,
+            )
+        return result
+
+    def get_router_dependencies(
+        self,
+        router_var: str,
+        file_path: Path,
+    ) -> list[str]:
+        """Return accumulated dependency names for a router from the tree."""
+        return self._registry.get_router_dependencies(router_var, file_path)
+
+
+# =============================================================================
+# Python Language Services
+# =============================================================================
+
+
+class PythonLanguageServices(LanguageServices):
+    """
+    Python-specific implementation of LanguageServices.
+
+    This factory builds all Python analysis services and wraps them
+    in protocol-compliant adapters.
+
+    Usage:
+        services = PythonLanguageServices()
+        context = services.build_context(
+            parsed_files,
+            project_root,
+            framework="fastapi"
+        )
+    """
+
+    def build_type_resolver(
+        self,
+        parsed_files: list[ParsedFile],
+        project_root: Path | None = None,
+    ) -> TypeResolver:
+        """Build Python type resolver (CrossFileResolver)."""
+        from .cross_file_resolver import build_cross_file_resolver
+
+        resolver = build_cross_file_resolver(parsed_files, project_root)
+        return PythonTypeResolverAdapter(resolver)
+
+    def build_constant_resolver(
+        self,
+        parsed_files: list[ParsedFile],
+        project_root: Path | None = None,
+    ) -> ConstantResolverProtocol | None:
+        """Build Python constant resolver."""
+        from .constant_resolver import build_constant_resolver
+
+        resolver = build_constant_resolver(parsed_files, project_root)
+        return PythonConstantResolverAdapter(resolver)
+
+    def build_path_resolver(
+        self,
+        parsed_files: list[ParsedFile],
+        project_root: Path | None = None,
+    ) -> PathResolverProtocol | None:
+        """Build Python path resolver."""
+        from .path_resolver import PathResolver as PythonPathResolver
+
+        resolver = PythonPathResolver(project_root)
+        for parsed in parsed_files:
+            resolver.process_file(parsed)
+
+        return PythonPathResolverAdapter(resolver)
+
+    def build_framework_services(
+        self,
+        framework: str,
+        parsed_files: list[ParsedFile],
+        project_root: Path | None = None,
+    ) -> dict[str, Any]:
+        """Build framework-specific services."""
+        services = {}
+
+        if framework.lower() == "fastapi":
+            services.update(self._build_fastapi_services(parsed_files, project_root))
+        elif framework.lower() == "flask":
+            services.update(self._build_flask_services(parsed_files, project_root))
+        # Add more frameworks as needed
+
+        return services
+
+    def _build_fastapi_services(
+        self,
+        parsed_files: list[ParsedFile],
+        project_root: Path | None,
+    ) -> dict[str, Any]:
+        """Build FastAPI-specific services."""
+        from .cbv_extractor import CBVExtractor
+        from .dynamic_route_detector import DynamicRouteDetector
+        from .router_registry import build_router_registry
+
+        # Router registry
+        registry = build_router_registry(parsed_files, project_root)
+
+        # Dynamic route detector
+        dynamic_detector = DynamicRouteDetector(project_root)
+        for parsed in parsed_files:
+            dynamic_detector.process_file(parsed)
+
+        # CBV extractor
+        cbv_extractor = CBVExtractor(project_root)
+        for parsed in parsed_files:
+            cbv_extractor.process_file(parsed)
+
+        return {
+            "router_registry": PythonRouterRegistryAdapter(registry),
+            "dynamic_route_detector": dynamic_detector,
+            "cbv_extractor": cbv_extractor,
+            # Keep raw registry for direct access if needed
+            "_raw_router_registry": registry,
+        }
+
+    def _build_flask_services(
+        self,
+        parsed_files: list[ParsedFile],
+        project_root: Path | None,
+    ) -> dict[str, Any]:
+        """Build Flask-specific services (placeholder)."""
+        # TODO: Implement Flask blueprint registry
+        return {}
+
+    # Override build_context to wire up Python-specific dependencies
+    def build_context(
+        self,
+        parsed_files: list[ParsedFile],
+        project_root: Path | None = None,
+        framework: str | None = None,
+    ) -> AnalysisContext:
+        """
+        Build complete analysis context for Python.
+
+        Wires up all services with proper dependencies.
+        """
+        # Build base services
+        type_resolver = self.build_type_resolver(parsed_files, project_root)
+        constant_resolver = self.build_constant_resolver(parsed_files, project_root)
+        path_resolver = self.build_path_resolver(parsed_files, project_root)
+
+        # Wire constant resolver into path resolver
+        if constant_resolver and path_resolver:
+            path_resolver.set_constant_resolver(constant_resolver)
+
+        # Build framework-specific services
+        framework_services = {}
+        router_registry = None
+
+        if framework:
+            framework_services = self.build_framework_services(
+                framework, parsed_files, project_root
+            )
+            router_registry = framework_services.get("router_registry")
+
+            # Wire constant resolver into router registry
+            if router_registry and constant_resolver:
+                router_registry.set_constant_resolver(constant_resolver)
+
+        # Store raw resolver for legacy plugins that need direct access
+        if isinstance(type_resolver, PythonTypeResolverAdapter):
+            framework_services["_raw_cross_file_resolver"] = type_resolver._resolver
+
+        return AnalysisContext(
+            type_resolver=type_resolver,
+            constant_resolver=constant_resolver,
+            path_resolver=path_resolver,
+            router_registry=router_registry,
+            project_root=project_root,
+            all_parsed_files=parsed_files,
+            language_services=framework_services,
+        )
+
+
+# =============================================================================
+# Factory Function
+# =============================================================================
+
+
+def get_python_language_services() -> PythonLanguageServices:
+    """Get a PythonLanguageServices instance."""
+    return PythonLanguageServices()