arcgraph 0.1.0__py3-none-any.whl

arcgraph/adapters/pydantic_adapter.py

@@ -0,0 +1,290 @@
+"""Pydantic model, field, and settings extraction."""
+
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass
+
+from arcgraph.adapters.common import (
+    AdapterAnalysis,
+    ImportAliases,
+    SemanticAdapter,
+    annotation_name,
+    call_name,
+    import_aliases,
+    keyword,
+    literal_str,
+    make_adapter_edge,
+    resolve_name,
+)
+from arcgraph.core.ids import (
+    class_id,
+    config_key_id,
+    model_field_id,
+    pydantic_model_id,
+)
+from arcgraph.core.schemas import Edge, FileRecord, Node
+
+
+@dataclass(frozen=True)
+class PydanticField:
+    name: str
+    annotation: str | None
+    node: ast.AST
+    value: ast.AST | None
+
+
+class PydanticAdapter(SemanticAdapter):
+    name = "pydantic"
+    capabilities = ("resource:pydantic_model", "resource:config", "edge:declares")
+    required_facts = ("class",)
+
+    MODEL_BASES = {"BaseModel", "pydantic.BaseModel"}
+    SETTINGS_BASES = {
+        "BaseSettings",
+        "pydantic.BaseSettings",
+        "pydantic_settings.BaseSettings",
+    }
+
+    def analyze(
+        self,
+        files: list[FileRecord],
+        parsed_files: dict[str, ast.Module],
+        nodes: list[Node],
+        module_names: set[str],
+    ) -> AdapterAnalysis:
+        del nodes
+        analysis = AdapterAnalysis()
+        model_count = 0
+        settings_count = 0
+        field_count = 0
+        config_key_count = 0
+
+        for file_record in files:
+            tree = parsed_files.get(file_record.path)
+            if tree is None:
+                continue
+            imports = import_aliases(file_record, tree, module_names)
+            classes = [item for item in tree.body if isinstance(item, ast.ClassDef)]
+            for stmt in classes:
+                kind = self._pydantic_kind(stmt, file_record, imports)
+                if kind is None:
+                    continue
+                qualname = f"{file_record.module}.{stmt.name}"
+                class_node_id = class_id(qualname)
+                schema_node = Node(
+                    id=pydantic_model_id(qualname),
+                    kind="pydantic_model",
+                    name=stmt.name,
+                    qualname=qualname,
+                    path=file_record.path,
+                    start_line=stmt.lineno,
+                    end_line=getattr(stmt, "end_lineno", stmt.lineno),
+                    properties={"model_kind": kind},
+                )
+                analysis.nodes.append(schema_node)
+                analysis.edges.append(
+                    self._edge(
+                        class_node_id,
+                        schema_node.id,
+                        "declares",
+                        "pydantic_model",
+                        file_record,
+                        stmt,
+                        f"{stmt.name} declares {kind}",
+                    )
+                )
+                model_count += 1
+                settings_count += 1 if kind == "settings" else 0
+
+                for field in self._fields(stmt):
+                    field_node = self._field_node(qualname, field, file_record, kind)
+                    analysis.nodes.append(field_node)
+                    analysis.edges.append(
+                        self._edge(
+                            class_node_id,
+                            field_node.id,
+                            "declares",
+                            "pydantic_field",
+                            file_record,
+                            field.node,
+                            f"{stmt.name}.{field.name}",
+                        )
+                    )
+                    field_count += 1
+                    if kind == "settings":
+                        config_node, env_key = self._config_node(
+                            stmt, field, file_record
+                        )
+                        analysis.nodes.append(config_node)
+                        analysis.edges.append(
+                            self._edge(
+                                class_node_id,
+                                config_node.id,
+                                "configures",
+                                "pydantic_settings",
+                                file_record,
+                                field.node,
+                                f"{stmt.name}.{field.name} -> {env_key}",
+                            )
+                        )
+                        analysis.edges.append(
+                            self._edge(
+                                field_node.id,
+                                config_node.id,
+                                "maps_to",
+                                "pydantic_settings",
+                                file_record,
+                                field.node,
+                                f"{field.name} maps to {env_key}",
+                            )
+                        )
+                        config_key_count += 1
+
+        analysis.nodes.sort(key=lambda node: node.id)
+        analysis.edges.sort(key=lambda edge: (edge.source, edge.target, edge.kind))
+        analysis.metrics = {
+            "pydantic_models": model_count,
+            "settings_models": settings_count,
+            "model_fields": field_count,
+            "config_keys": config_key_count,
+            "discovered_registrations": model_count,
+            "resolved_handlers": model_count,
+            "unresolved_registrations": 0,
+        }
+        return analysis
+
+    def _pydantic_kind(
+        self,
+        stmt: ast.ClassDef,
+        file_record: FileRecord,
+        imports: ImportAliases,
+    ) -> str | None:
+        resolved_bases = {
+            self._resolved_annotation(base, file_record, imports) for base in stmt.bases
+        }
+        if resolved_bases & self.SETTINGS_BASES:
+            return "settings"
+        if resolved_bases & self.MODEL_BASES:
+            return "model"
+        return None
+
+    @staticmethod
+    def _resolved_annotation(
+        node: ast.AST, file_record: FileRecord, imports: ImportAliases
+    ) -> str | None:
+        name = annotation_name(node)
+        if not name:
+            return None
+        resolved = resolve_name(name, file_record, imports)
+        return resolved if "." in resolved else name.rsplit(".", 1)[-1]
+
+    def _fields(self, stmt: ast.ClassDef) -> list[PydanticField]:
+        fields: list[PydanticField] = []
+        for item in stmt.body:
+            if isinstance(item, ast.AnnAssign) and isinstance(item.target, ast.Name):
+                fields.append(
+                    PydanticField(
+                        name=item.target.id,
+                        annotation=annotation_name(item.annotation),
+                        node=item,
+                        value=item.value,
+                    )
+                )
+            elif isinstance(item, ast.Assign):
+                for target in item.targets:
+                    if isinstance(target, ast.Name) and self._is_field_call(item.value):
+                        fields.append(
+                            PydanticField(
+                                name=target.id,
+                                annotation=None,
+                                node=item,
+                                value=item.value,
+                            )
+                        )
+        return fields
+
+    @staticmethod
+    def _is_field_call(node: ast.AST | None) -> bool:
+        if not isinstance(node, ast.Call):
+            return False
+        name = call_name(node.func)
+        return bool(name and name.rsplit(".", 1)[-1] in {"Field", "PrivateAttr"})
+
+    @staticmethod
+    def _field_node(
+        model_qualname: str,
+        field: PydanticField,
+        file_record: FileRecord,
+        model_kind: str,
+    ) -> Node:
+        qualname = f"{model_qualname}.{field.name}"
+        return Node(
+            id=model_field_id(qualname),
+            kind="model_field",
+            name=field.name,
+            qualname=qualname,
+            path=file_record.path,
+            start_line=getattr(field.node, "lineno", None),
+            end_line=getattr(
+                field.node, "end_lineno", getattr(field.node, "lineno", None)
+            ),
+            properties={"annotation": field.annotation, "model_kind": model_kind},
+        )
+
+    def _config_node(
+        self,
+        stmt: ast.ClassDef,
+        field: PydanticField,
+        file_record: FileRecord,
+    ) -> tuple[Node, str]:
+        env_key = self._field_env_key(field) or field.name.upper()
+        node_id = config_key_id(f"env:{env_key}")
+        return (
+            Node(
+                id=node_id,
+                kind="config",
+                name=env_key,
+                qualname=env_key,
+                path=file_record.path,
+                start_line=getattr(field.node, "lineno", stmt.lineno),
+                properties={
+                    "source": "pydantic_settings",
+                    "settings_class": stmt.name,
+                    "field": field.name,
+                    "key": env_key,
+                },
+            ),
+            env_key,
+        )
+
+    @staticmethod
+    def _field_env_key(field: PydanticField) -> str | None:
+        if not isinstance(field.value, ast.Call):
+            return None
+        for key in ("env", "validation_alias", "alias"):
+            value = literal_str(keyword(field.value, key))
+            if value:
+                return value
+        return None
+
+    @staticmethod
+    def _edge(
+        source: str,
+        target: str,
+        kind: str,
+        evidence_kind: str,
+        file_record: FileRecord,
+        node: ast.AST,
+        detail: str,
+    ) -> Edge:
+        return make_adapter_edge(
+            source=source,
+            target=target,
+            kind=kind,
+            confidence="heuristic",
+            evidence_kind=evidence_kind,
+            file_record=file_record,
+            node=node,
+            detail=detail,
+        )

arcgraph/adapters/pytest_adapter.py

@@ -0,0 +1,221 @@
+"""pytest test case and fixture extraction."""
+
+from __future__ import annotations
+
+import ast
+
+from arcgraph.adapters.common import (
+    AdapterAnalysis,
+    SemanticAdapter,
+    call_name,
+    iter_symbol_defs,
+    literal_str,
+    make_adapter_edge,
+    symbol_id_for_def,
+)
+from arcgraph.adapters.pytest_fixtures import FixtureCatalog
+from arcgraph.core.ids import pytest_case_id
+from arcgraph.core.schemas import Edge, FileRecord, Node
+
+
+class PytestAdapter(SemanticAdapter):
+    name = "pytest"
+    capabilities = ("entrypoint:test_case", "resource:pytest_fixture", "edge:injects")
+    required_facts = ("function",)
+    BUILTIN_FIXTURE_ARGS = {
+        "anyio_backend",
+        "benchmark",
+        "cache",
+        "capfd",
+        "capfdbinary",
+        "caplog",
+        "capsys",
+        "capsysbinary",
+        "cls",
+        "doctest_namespace",
+        "event_loop",
+        "monkeypatch",
+        "pytestconfig",
+        "record_property",
+        "record_testsuite_property",
+        "record_xml_attribute",
+        "recwarn",
+        "request",
+        "self",
+        "tmp_path",
+        "tmp_path_factory",
+        "tmpdir",
+        "tmpdir_factory",
+    }
+
+    def analyze(
+        self,
+        files: list[FileRecord],
+        parsed_files: dict[str, ast.Module],
+        nodes: list[Node],
+        module_names: set[str],
+    ) -> AdapterAnalysis:
+        analysis = AdapterAnalysis()
+        catalog = FixtureCatalog(files, parsed_files, module_names, nodes)
+        fixture_count = 0
+        test_count = 0
+        injection_count = 0
+        unresolved_fixture_args = 0
+
+        for fixture in catalog.fixtures:
+            file_record, stmt = fixture.file, fixture.stmt
+            qualname = fixture.node_id.removeprefix("fixture:")
+            analysis.nodes.append(
+                Node(
+                    id=fixture.node_id,
+                    kind="pytest_fixture",
+                    name=fixture.name,
+                    qualname=qualname,
+                    path=file_record.path,
+                    start_line=stmt.lineno,
+                    end_line=stmt.end_lineno,
+                    properties={
+                        "handler": fixture.handler_id,
+                        "autouse": fixture.autouse,
+                    },
+                )
+            )
+            analysis.edges.append(
+                self._edge(
+                    fixture.node_id,
+                    fixture.handler_id,
+                    "invokes",
+                    file_record,
+                    stmt,
+                    f"pytest fixture {fixture.name}",
+                )
+            )
+            fixture_count += 1
+
+        for file_record in files:
+            tree = parsed_files.get(file_record.path)
+            if tree is None:
+                continue
+            for stmt, qualified_name, id_factory in iter_symbol_defs(tree):
+                if not isinstance(stmt, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                    continue
+                if not catalog.collection.is_test(
+                    file_record, stmt, qualified_name.rpartition(".")[0]
+                ):
+                    continue
+                qualname = f"{file_record.module}.{qualified_name}"
+                source_id = symbol_id_for_def(file_record, qualified_name, id_factory)
+                test_node_id = pytest_case_id(qualname)
+                marks = self._marks(stmt)
+                analysis.nodes.append(
+                    Node(
+                        id=test_node_id,
+                        kind="test_case",
+                        name=stmt.name,
+                        qualname=qualname,
+                        path=file_record.path,
+                        start_line=stmt.lineno,
+                        end_line=getattr(stmt, "end_lineno", stmt.lineno),
+                        properties={
+                            "handler": source_id,
+                            "marks": marks,
+                            "parametrized": "parametrize" in marks,
+                        },
+                    )
+                )
+                analysis.edges.append(
+                    self._edge(
+                        test_node_id,
+                        source_id,
+                        "invokes",
+                        file_record,
+                        stmt,
+                        f"pytest test {stmt.name}",
+                    )
+                )
+                test_count += 1
+                owner = qualified_name.rpartition(".")[0]
+                parametrized_args = catalog.direct_parameters(stmt, file_record, owner)
+                requested_fixtures = [
+                    *catalog.parameters(stmt, owner),
+                    *self._usefixtures_args(stmt),
+                    *catalog.autouse_names(file_record, owner),
+                ]
+                for arg in dict.fromkeys(requested_fixtures):
+                    if arg in parametrized_args:
+                        continue
+                    fixture = catalog.resolve(arg, file_record, owner)
+                    if fixture is None:
+                        if (
+                            arg not in self.BUILTIN_FIXTURE_ARGS
+                            and arg not in parametrized_args
+                        ):
+                            unresolved_fixture_args += 1
+                        continue
+                    analysis.edges.append(
+                        self._edge(
+                            test_node_id,
+                            fixture.node_id,
+                            "injects",
+                            file_record,
+                            stmt,
+                            f"pytest fixture argument {arg}",
+                        )
+                    )
+                    injection_count += 1
+
+        analysis.nodes.sort(key=lambda node: node.id)
+        analysis.edges.sort(key=lambda edge: (edge.source, edge.target, edge.kind))
+        analysis.metrics = {
+            "test_cases": test_count,
+            "fixtures": fixture_count,
+            "fixture_injections": injection_count,
+            "unresolved_fixture_injections": unresolved_fixture_args,
+            "discovered_registrations": test_count + fixture_count,
+            "resolved_handlers": test_count + fixture_count,
+            "unresolved_registrations": 0,
+        }
+        return analysis
+
+    @staticmethod
+    def _marks(stmt: ast.FunctionDef | ast.AsyncFunctionDef) -> list[str]:
+        marks: set[str] = set()
+        for decorator in stmt.decorator_list:
+            target = decorator.func if isinstance(decorator, ast.Call) else decorator
+            name = call_name(target)
+            if name and name.startswith("pytest.mark."):
+                marks.add(name.rsplit(".", 1)[-1])
+        return sorted(marks)
+
+    @staticmethod
+    def _usefixtures_args(stmt: ast.FunctionDef | ast.AsyncFunctionDef) -> list[str]:
+        names: list[str] = []
+        for decorator in stmt.decorator_list:
+            if not isinstance(decorator, ast.Call):
+                continue
+            name = call_name(decorator.func)
+            if name not in {"pytest.mark.usefixtures", "mark.usefixtures"}:
+                continue
+            names.extend(value for arg in decorator.args if (value := literal_str(arg)))
+        return names
+
+    @staticmethod
+    def _edge(
+        source: str,
+        target: str,
+        kind: str,
+        file_record: FileRecord,
+        node: ast.AST,
+        detail: str,
+    ) -> Edge:
+        return make_adapter_edge(
+            source=source,
+            target=target,
+            kind=kind,
+            confidence="confirmed",
+            evidence_kind="pytest_adapter",
+            file_record=file_record,
+            node=node,
+            detail=detail,
+            semantic_role=f"{kind}:pytest",
+        )

arcgraph/adapters/pytest_collection.py

@@ -0,0 +1,96 @@
+"""Static pytest collection patterns; never import project configuration code."""
+
+from __future__ import annotations
+
+import ast
+import configparser
+from dataclasses import dataclass
+from fnmatch import fnmatchcase
+from pathlib import Path, PurePosixPath
+import shlex
+import tomllib
+
+from arcgraph.core.schemas import FileRecord
+
+
+@dataclass(frozen=True)
+class PytestCollection:
+    python_files: tuple[str, ...] = ("test_*.py", "*_test.py")
+    python_functions: tuple[str, ...] = ("test",)
+    python_classes: tuple[str, ...] = ("Test",)
+
+    @classmethod
+    def from_files(cls, files: list[FileRecord]) -> PytestCollection:
+        if not files:
+            return cls()
+        file = files[0]
+        root = Path(file.abs_path)
+        for _ in PurePosixPath(file.path).parts:
+            root = root.parent
+        return cls.from_root(root)
+
+    @classmethod
+    def from_root(cls, root: Path) -> PytestCollection:
+        for name, section in (
+            ("pytest.ini", "pytest"),
+            (".pytest.ini", "pytest"),
+            ("pyproject.toml", ""),
+            ("tox.ini", "pytest"),
+            ("setup.cfg", "tool:pytest"),
+        ):
+            path = root / name
+            if not path.is_file():
+                continue
+            try:
+                if name == "pyproject.toml":
+                    values = (
+                        tomllib.loads(path.read_text(encoding="utf-8"))
+                        .get("tool", {})
+                        .get("pytest", {})
+                        .get("ini_options")
+                    )
+                    if values is None:
+                        continue
+                else:
+                    config = configparser.ConfigParser(interpolation=None)
+                    config.read_string(path.read_text(encoding="utf-8"))
+                    if not config.has_section(section):
+                        if name in {"pytest.ini", ".pytest.ini"}:
+                            return cls()
+                        continue
+                    values = config[section]
+                defaults = cls()
+                patterns = {}
+                for key in ("python_files", "python_functions", "python_classes"):
+                    value = values.get(key, getattr(defaults, key))
+                    patterns[key] = tuple(
+                        shlex.split(value) if isinstance(value, str) else value
+                    )
+                if any(
+                    not isinstance(p, str) for group in patterns.values() for p in group
+                ):
+                    return cls((), (), ())
+                return cls(**patterns)
+            except (OSError, ValueError, TypeError, AttributeError, configparser.Error):
+                # Invalid static configuration provides no collection evidence.
+                return cls((), (), ())
+        return cls()
+
+    def file_matches(self, path: str) -> bool:
+        return any(fnmatchcase(PurePosixPath(path).name, p) for p in self.python_files)
+
+    @staticmethod
+    def _name_matches(name: str, patterns: tuple[str, ...]) -> bool:
+        return any(name.startswith(p) or fnmatchcase(name, p) for p in patterns)
+
+    def is_test(
+        self,
+        file: FileRecord,
+        stmt: ast.FunctionDef | ast.AsyncFunctionDef,
+        owner: str = "",
+    ) -> bool:
+        return (
+            self.file_matches(file.path)
+            and self._name_matches(stmt.name, self.python_functions)
+            and (not owner or self._name_matches(owner, self.python_classes))
+        )