osscodeiq 0.0.0__py3-none-any.whl

osscodeiq/detectors/python/pydantic_models.py

@@ -0,0 +1,115 @@
+"""Pydantic model detector."""
+
+from __future__ import annotations
+
+import re
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.detectors.utils import decode_text
+from osscodeiq.models.graph import EdgeKind, GraphEdge, GraphNode, NodeKind, SourceLocation
+
+
+class PydanticModelDetector:
+    """Detects Pydantic model and settings definitions."""
+
+    name: str = "python.pydantic_models"
+    supported_languages: tuple[str, ...] = ("python",)
+
+    _PYDANTIC_CLASS_RE = re.compile(
+        r"^class\s+(\w+)\s*\(\s*(\w*(?:BaseModel|BaseSettings)\w*)\s*\)", re.MULTILINE
+    )
+    _FIELD_RE = re.compile(r"^\s+(\w+)\s*:\s*(\w[\w\[\], |]*)", re.MULTILINE)
+    _VALIDATOR_RE = re.compile(
+        r"@(?:validator|field_validator)\s*\(\s*[\"'](\w+)", re.MULTILINE
+    )
+    _CONFIG_CLASS_RE = re.compile(r"^\s+class\s+Config\s*:", re.MULTILINE)
+    _CONFIG_ATTR_RE = re.compile(r"^\s{8}(\w+)\s*=\s*(.+)", re.MULTILINE)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+
+        # Track known model names for inheritance edges
+        known_models: dict[str, str] = {}
+
+        for match in self._PYDANTIC_CLASS_RE.finditer(text):
+            class_name = match.group(1)
+            base_class = match.group(2)
+            line = text[: match.start()].count("\n") + 1
+
+            is_settings = "BaseSettings" in base_class
+
+            # Determine class body boundaries
+            class_start = match.start()
+            next_class = re.search(r"\nclass\s+\w+", text[match.end() :])
+            class_body = (
+                text[class_start : match.end() + next_class.start()]
+                if next_class
+                else text[class_start:]
+            )
+
+            # Extract fields
+            fields = []
+            field_types: dict[str, str] = {}
+            for fm in self._FIELD_RE.finditer(class_body):
+                fname = fm.group(1)
+                ftype = fm.group(2).strip()
+                if fname not in ("class", "Config", "model_config"):
+                    fields.append(fname)
+                    field_types[fname] = ftype
+
+            # Extract validators
+            validators = [
+                vm.group(1) for vm in self._VALIDATOR_RE.finditer(class_body)
+            ]
+
+            # Extract Config class properties
+            config_props: dict[str, str] = {}
+            config_match = self._CONFIG_CLASS_RE.search(class_body)
+            if config_match:
+                config_block_start = config_match.end()
+                # Find next dedented line or end
+                config_block_end = len(class_body)
+                for cm in re.finditer(r"\n\S", class_body[config_block_start:]):
+                    config_block_end = config_block_start + cm.start()
+                    break
+                config_block = class_body[config_block_start:config_block_end]
+                for attr_match in self._CONFIG_ATTR_RE.finditer(config_block):
+                    config_props[attr_match.group(1)] = attr_match.group(2).strip()
+
+            node_kind = NodeKind.CONFIG_DEFINITION if is_settings else NodeKind.ENTITY
+            node_id = f"pydantic:{ctx.file_path}:model:{class_name}"
+
+            result.nodes.append(
+                GraphNode(
+                    id=node_id,
+                    kind=node_kind,
+                    label=class_name,
+                    fqn=f"{ctx.file_path}::{class_name}",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                    annotations=validators,
+                    properties={
+                        "fields": fields,
+                        "field_types": field_types,
+                        "framework": "pydantic",
+                        "base_class": base_class,
+                        **({"config": config_props} if config_props else {}),
+                    },
+                )
+            )
+
+            known_models[class_name] = node_id
+
+            # Check for inheritance from a known model
+            if base_class in known_models:
+                result.edges.append(
+                    GraphEdge(
+                        source=node_id,
+                        target=known_models[base_class],
+                        kind=EdgeKind.EXTENDS,
+                        label=f"{class_name} extends {base_class}",
+                    )
+                )
+
+        return result

osscodeiq/detectors/python/python_structures.py

@@ -0,0 +1,234 @@
+"""Regex-based Python structures detector for Python source files."""
+
+from __future__ import annotations
+
+import re
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.detectors.utils import decode_text, find_line_number
+from osscodeiq.models.graph import (
+    EdgeKind,
+    GraphEdge,
+    GraphNode,
+    NodeKind,
+    SourceLocation,
+)
+
+_CLASS_RE = re.compile(r'^class\s+(\w+)(?:\(([^)]*)\))?:', re.MULTILINE)
+_FUNC_RE = re.compile(r'^([^\S\n]*)(async\s+)?def\s+(\w+)\s*\(', re.MULTILINE)
+_IMPORT_RE = re.compile(r'^(?:from\s+([\w.]+)\s+)?import\s+([\w., ]+)', re.MULTILINE)
+_DECORATOR_RE = re.compile(r'^([^\S\n]*)@(\w[\w.]*)', re.MULTILINE)
+_ALL_RE = re.compile(r'__all__\s*=\s*\[([^\]]*)\]', re.DOTALL)
+
+
+def _collect_decorators(text: str) -> dict[int, list[str]]:
+    """Map each decorator's line number to the decorator name.
+
+    Returns a dict keyed by 1-based line number of the decorator.
+    """
+    result: dict[int, list[str]] = {}
+    for m in _DECORATOR_RE.finditer(text):
+        line = find_line_number(text, m.start())
+        result.setdefault(line, []).append(m.group(2))
+    return result
+
+
+def _find_decorators_for_line(
+    decorator_map: dict[int, list[str]], target_line: int
+) -> list[str]:
+    """Collect all decorator names immediately above a target line."""
+    decorators: list[str] = []
+    line = target_line - 1
+    while line in decorator_map:
+        decorators.extend(decorator_map[line])
+        line -= 1
+    # Reverse so top-most decorator is first
+    decorators.reverse()
+    return decorators
+
+
+def _find_enclosing_class(
+    class_ranges: list[tuple[str, int, int]], line: int, func_indent: int
+) -> str | None:
+    """Find the class name that encloses a given line number.
+
+    A function is considered inside a class if it appears after the class
+    declaration and is indented more than the class itself.
+
+    class_ranges is a list of (class_name, start_line, indent_col).
+    """
+    for class_name, start_line, class_indent in reversed(class_ranges):
+        if line > start_line and func_indent > class_indent:
+            return class_name
+    return None
+
+
+class PythonStructuresDetector:
+    """Detects Python classes, functions, imports, decorators, and __all__ exports."""
+
+    name: str = "python_structures"
+    supported_languages: tuple[str, ...] = ("python",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+        fp = ctx.file_path
+        file_node_id = fp
+
+        # Collect decorators by line number
+        decorator_map = _collect_decorators(text)
+
+        # __all__ exports
+        all_match = _ALL_RE.search(text)
+        all_exports: list[str] | None = None
+        if all_match:
+            raw = all_match.group(1)
+            # Extract quoted names
+            all_exports = re.findall(r"""['"](\w+)['"]""", raw)
+
+        # Classes — track them for method association
+        class_ranges: list[tuple[str, int, int]] = []  # (name, line, indent_col)
+        for m in _CLASS_RE.finditer(text):
+            class_name = m.group(1)
+            bases_str = m.group(2)
+            line = find_line_number(text, m.start())
+            node_id = f"py:{fp}:class:{class_name}"
+
+            # Find indent of the class declaration
+            line_start_offset = text.rfind("\n", 0, m.start()) + 1
+            indent = m.start() - line_start_offset
+
+            class_ranges.append((class_name, line, indent))
+
+            annotations = _find_decorators_for_line(decorator_map, line)
+
+            properties: dict = {}
+            if bases_str:
+                bases = [b.strip() for b in bases_str.split(",") if b.strip()]
+                properties["bases"] = bases
+            if all_exports and class_name in all_exports:
+                properties["exported"] = True
+
+            result.nodes.append(GraphNode(
+                id=node_id,
+                kind=NodeKind.CLASS,
+                label=class_name,
+                fqn=class_name,
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=fp,
+                    line_start=line,
+                ),
+                annotations=annotations,
+                properties=properties,
+            ))
+
+            # EXTENDS edges for base classes
+            if bases_str:
+                bases = [b.strip() for b in bases_str.split(",") if b.strip()]
+                for base in bases:
+                    result.edges.append(GraphEdge(
+                        source=node_id,
+                        target=base,
+                        kind=EdgeKind.EXTENDS,
+                        label=f"{class_name} extends {base}",
+                    ))
+
+        # Functions and methods
+        for m in _FUNC_RE.finditer(text):
+            indent_str = m.group(1)
+            is_async = m.group(2) is not None
+            func_name = m.group(3)
+            line = find_line_number(text, m.start())
+            indent_len = len(indent_str)
+
+            annotations = _find_decorators_for_line(decorator_map, line)
+
+            properties: dict = {}
+            if is_async:
+                properties["async"] = True
+            if all_exports and func_name in all_exports:
+                properties["exported"] = True
+
+            if indent_len == 0:
+                # Top-level function
+                node_id = f"py:{fp}:func:{func_name}"
+                result.nodes.append(GraphNode(
+                    id=node_id,
+                    kind=NodeKind.METHOD,
+                    label=func_name,
+                    fqn=func_name,
+                    module=ctx.module_name,
+                    location=SourceLocation(
+                        file_path=fp,
+                        line_start=line,
+                    ),
+                    annotations=annotations,
+                    properties=properties,
+                ))
+            else:
+                # Indented def — check if it's inside a class
+                enclosing_class = _find_enclosing_class(class_ranges, line, indent_len)
+                if enclosing_class:
+                    node_id = f"py:{fp}:class:{enclosing_class}:method:{func_name}"
+                    properties["class"] = enclosing_class
+                    result.nodes.append(GraphNode(
+                        id=node_id,
+                        kind=NodeKind.METHOD,
+                        label=f"{enclosing_class}.{func_name}",
+                        fqn=f"{enclosing_class}.{func_name}",
+                        module=ctx.module_name,
+                        location=SourceLocation(
+                            file_path=fp,
+                            line_start=line,
+                        ),
+                        annotations=annotations,
+                        properties=properties,
+                    ))
+                    # DEFINES edge from class to method
+                    class_node_id = f"py:{fp}:class:{enclosing_class}"
+                    result.edges.append(GraphEdge(
+                        source=class_node_id,
+                        target=node_id,
+                        kind=EdgeKind.DEFINES,
+                        label=f"{enclosing_class} defines {func_name}",
+                    ))
+
+        # Imports
+        for m in _IMPORT_RE.finditer(text):
+            from_module = m.group(1)
+            import_names = m.group(2)
+            if from_module:
+                result.edges.append(GraphEdge(
+                    source=file_node_id,
+                    target=from_module,
+                    kind=EdgeKind.IMPORTS,
+                    label=f"{fp} imports {from_module}",
+                ))
+            else:
+                for name in import_names.split(","):
+                    name = name.strip()
+                    if name:
+                        result.edges.append(GraphEdge(
+                            source=file_node_id,
+                            target=name,
+                            kind=EdgeKind.IMPORTS,
+                            label=f"{fp} imports {name}",
+                        ))
+
+        # __all__ property on a file-level module node (only if present)
+        if all_exports is not None:
+            result.nodes.append(GraphNode(
+                id=f"py:{fp}:module",
+                kind=NodeKind.MODULE,
+                label=fp,
+                fqn=fp,
+                module=ctx.module_name,
+                location=SourceLocation(
+                    file_path=fp,
+                    line_start=find_line_number(text, all_match.start()),
+                ),
+                properties={"__all__": all_exports},
+            ))
+
+        return result

osscodeiq/detectors/python/sqlalchemy_models.py

@@ -0,0 +1,82 @@
+"""SQLAlchemy model detector."""
+
+from __future__ import annotations
+
+import re
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.detectors.utils import decode_text
+from osscodeiq.models.graph import EdgeKind, GraphEdge, GraphNode, NodeKind, SourceLocation
+
+
+class SQLAlchemyModelDetector:
+    """Detects SQLAlchemy ORM models (declarative base classes)."""
+
+    name: str = "python.sqlalchemy_models"
+    supported_languages: tuple[str, ...] = ("python",)
+
+    # class User(Base): or class User(db.Model):
+    _MODEL_PATTERN = re.compile(
+        r"class\s+(\w+)\(([^)]*(?:Base|Model|DeclarativeBase)[^)]*)\):"
+    )
+
+    # __tablename__ = 'users'
+    _TABLE_NAME = re.compile(r"__tablename__\s*=\s*['\"](\w+)['\"]")
+
+    # Column definitions: name = Column(String, ...) or name: Mapped[str] = mapped_column(...)
+    _COLUMN_PATTERN = re.compile(
+        r"(\w+)\s*(?::\s*Mapped\[.*?\])?\s*=\s*(?:Column|mapped_column)\("
+    )
+
+    # Relationship: orders = relationship("Order", ...) or orders: Mapped[list["Order"]]
+    _RELATIONSHIP_PATTERN = re.compile(
+        r"(\w+)\s*(?::\s*Mapped\[.*?\])?\s*=\s*relationship\(\s*['\"](\w+)['\"]"
+    )
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+
+        for match in self._MODEL_PATTERN.finditer(text):
+            class_name = match.group(1)
+            line = text[:match.start()].count("\n") + 1
+
+            # Find the class body (rough: from class line to next class or end)
+            class_start = match.start()
+            next_class = re.search(r"\nclass\s+\w+", text[match.end():])
+            class_body = text[class_start:match.end() + next_class.start()] if next_class else text[class_start:]
+
+            # Extract table name
+            table_match = self._TABLE_NAME.search(class_body)
+            table_name = table_match.group(1) if table_match else class_name.lower() + "s"
+
+            # Extract columns
+            columns = [m.group(1) for m in self._COLUMN_PATTERN.finditer(class_body)]
+
+            node_id = f"entity:{ctx.module_name or ''}:{class_name}"
+            result.nodes.append(GraphNode(
+                id=node_id,
+                kind=NodeKind.ENTITY,
+                label=class_name,
+                fqn=f"{ctx.file_path}::{class_name}",
+                module=ctx.module_name,
+                location=SourceLocation(file_path=ctx.file_path, line_start=line),
+                properties={
+                    "table_name": table_name,
+                    "columns": columns,
+                    "framework": "sqlalchemy",
+                },
+            ))
+
+            # Extract relationships
+            for rel_match in self._RELATIONSHIP_PATTERN.finditer(class_body):
+                target_class = rel_match.group(2)
+                target_id = f"entity:{ctx.module_name or ''}:{target_class}"
+                result.edges.append(GraphEdge(
+                    source=node_id,
+                    target=target_id,
+                    kind=EdgeKind.MAPS_TO,
+                    label=rel_match.group(1),
+                ))
+
+        return result

osscodeiq/detectors/registry.py

@@ -0,0 +1,100 @@
+"""Plugin registry for OSSCodeIQ detectors."""
+
+from __future__ import annotations
+
+import importlib
+import importlib.metadata
+import logging
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from osscodeiq.detectors.base import Detector
+
+logger = logging.getLogger(__name__)
+
+
+class DetectorRegistry:
+    """Registry that manages detector instances and plugin discovery."""
+
+    def __init__(self) -> None:
+        self._detectors: list[Detector] = []
+        self._by_name: dict[str, Detector] = {}
+
+    def register(self, detector: Detector) -> None:
+        """Add a detector to the registry."""
+        if detector.name in self._by_name:
+            logger.warning("Detector %r already registered, skipping", detector.name)
+            return
+        self._detectors.append(detector)
+        self._by_name[detector.name] = detector
+
+    def load_builtin_detectors(self) -> None:
+        """Import and register all built-in detectors via package scanning."""
+        import pkgutil
+
+        import osscodeiq.detectors as detectors_pkg
+
+        # Walk all subpackages under osscodeiq.detectors
+        skip = {"registry", "base", "utils", "__init__"}
+        module_paths = []
+        for importer, modname, ispkg in pkgutil.walk_packages(
+            detectors_pkg.__path__,
+            prefix="osscodeiq.detectors.",
+        ):
+            # Skip non-detector modules
+            short_name = modname.rsplit(".", 1)[-1]
+            if short_name in skip or short_name.startswith("_"):
+                continue
+            module_paths.append(modname)
+
+        # Sort for deterministic registration order
+        module_paths.sort()
+
+        for module_path in module_paths:
+            try:
+                mod = importlib.import_module(module_path)
+                # Convention: each module exposes a `detector` attribute or a class
+                # ending with "Detector"
+                if hasattr(mod, "detector"):
+                    self.register(mod.detector)
+                else:
+                    for attr_name in dir(mod):
+                        obj = getattr(mod, attr_name)
+                        if (
+                            isinstance(obj, type)
+                            and attr_name.endswith("Detector")
+                            and hasattr(obj, "detect")
+                        ):
+                            self.register(obj())
+                            break
+            except Exception:
+                logger.debug("Could not load detector module %s", module_path, exc_info=True)
+
+    def load_plugin_detectors(self) -> None:
+        """Discover detectors via setuptools entry points."""
+        try:
+            eps = importlib.metadata.entry_points(group="osscodeiq.detectors")
+        except TypeError:
+            # Python < 3.12 compat
+            eps = importlib.metadata.entry_points().get("osscodeiq.detectors", [])
+        for ep in eps:
+            try:
+                detector_or_factory = ep.load()
+                if callable(detector_or_factory) and isinstance(detector_or_factory, type):
+                    self.register(detector_or_factory())
+                else:
+                    self.register(detector_or_factory)
+            except Exception:
+                logger.warning("Failed to load plugin detector %s", ep.name, exc_info=True)
+
+    def detectors_for_language(self, language: str) -> list[Detector]:
+        """Return all detectors that support a given language."""
+        return [d for d in self._detectors if language in d.supported_languages]
+
+    def all_detectors(self) -> list[Detector]:
+        """Return all registered detectors."""
+        return list(self._detectors)
+
+    def get(self, name: str) -> Detector | None:
+        """Get a detector by name."""
+        return self._by_name.get(name)