deproc-core 0.1.0__tar.gz

deproc_core-0.1.0/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: deproc-core
+Version: 0.1.0
+Summary: Language-agnostic core contracts and runtime for deproc plugins.
+Author-email: Gurveer Singh Virk <gurveervirk.15517@gmail.com>
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/gurveervirk/deproc
+Project-URL: Repository, https://github.com/gurveervirk/deproc
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10

deproc_core-0.1.0/deproc/core/__init__.py

@@ -0,0 +1,5 @@
+from .discovery import find_source_files
+
+__all__ = [
+    "find_source_files",
+]

deproc_core-0.1.0/deproc/core/context.py

@@ -0,0 +1,207 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .interfaces.linker import Linker
+    from .interfaces.parser import SourceParser
+    from .interfaces.resolver import Resolver
+    from .interfaces.symbol_cache import SymbolCache
+
+from .runtime import EntityRegistry
+
+logger = logging.getLogger(__name__)
+
+class Context:
+    def __init__(self, base_path: str = "", copy_from: Context | None = None):
+        if copy_from:
+            self.base_path = copy_from.base_path
+            self.entity_registry = copy_from.entity_registry
+            self._language_aliases = dict(copy_from._language_aliases)
+            self._language_extensions = dict(copy_from._language_extensions)
+            self._all_languages = set(copy_from._all_languages)
+            self._all_file_extensions = set(copy_from._all_file_extensions)
+            self._selected_languages = set(copy_from._selected_languages)
+            self._selected_file_extensions = set(copy_from._selected_file_extensions)
+            self._parsers = dict(copy_from._parsers)
+            self._resolvers = dict(copy_from._resolvers)
+            self._linkers = dict(copy_from._linkers)
+            self.symbol_caches = dict(copy_from.symbol_caches)
+            self._skip_paths = set(copy_from._skip_paths)
+        else:
+            self.base_path = base_path
+            self.entity_registry = EntityRegistry()
+            self._language_aliases: dict[str, list[str]] = {}
+            self._language_extensions: dict[str, list[str]] = {}
+            self._all_languages: set[str] = set()
+            self._all_file_extensions: set[str] = set()
+            self._selected_languages: set[str] = set()
+            self._selected_file_extensions: set[str] = set()
+            self._skip_paths: set[str] = set()
+            self._parsers: dict[str, SourceParser] = {}
+            self._resolvers: dict[str, Resolver] = {}
+            self._linkers: dict[str, Linker] = {}
+            self.symbol_caches: dict[str, SymbolCache] = {}
+
+    def set_language(
+        self,
+        language: str,
+        file_extensions: list[str],
+        aliases: list[str] | None = None,
+    ) -> None:
+        normalized = language.strip().lower()
+        normalized_extensions: list[str] = []
+        for ext in file_extensions:
+            e = ext.strip().lower()
+            if not e.startswith("."):
+                e = f".{e}"
+                logger.warning("Normalized file extension '%s' to '%s' for language '%s'", ext, e, normalized)
+            normalized_extensions.append(e)
+        self._language_extensions[normalized] = normalized_extensions
+        if aliases:
+            self._language_aliases[normalized] = [a.strip().lower() for a in aliases]
+        else:
+            self._language_aliases[normalized] = []
+        self._all_languages.add(normalized)
+        self._selected_languages.add(normalized)
+        self._all_file_extensions.update(normalized_extensions)
+        self._selected_file_extensions.update(normalized_extensions)
+
+    @property
+    def selected_languages(self) -> set[str]:
+        return self._selected_languages
+
+    @property
+    def selected_file_extensions(self) -> set[str]:
+        return self._selected_file_extensions
+
+    @property
+    def skip_paths(self) -> set[str]:
+        return self._skip_paths
+
+    def set_skip_paths(self, paths: set[str]) -> None:
+        self._skip_paths = set(paths)
+
+    def _normalize_language(self, language: str) -> str:
+        normalized = language.strip().lower()
+        for canonical, aliases in self._language_aliases.items():
+            if normalized == canonical or normalized in aliases:
+                return canonical
+        return normalized
+
+    def _normalize_extension(self, extension: str) -> str:
+        normalized = extension.strip().lower()
+        if not normalized.startswith("."):
+            normalized = f".{normalized}"
+        return normalized
+
+    def select_languages(self, languages: list[str]) -> None:
+        for lang in languages:
+            normalized = self._normalize_language(lang)
+            exclude = normalized.startswith("!")
+            if exclude:
+                normalized = normalized[1:]
+            if normalized in self._all_languages:
+                if exclude:
+                    self._selected_languages.discard(normalized)
+                else:
+                    self._selected_languages.add(normalized)
+
+    def select_file_extensions(self, extensions: list[str]) -> None:
+        for ext in extensions:
+            raw = ext.strip().lower()
+            exclude = raw.startswith("!")
+            if exclude:
+                raw = raw[1:]
+            normalized = self._normalize_extension(raw)
+            if normalized in self._all_file_extensions:
+                if exclude:
+                    self._selected_file_extensions.discard(normalized)
+                else:
+                    self._selected_file_extensions.add(normalized)
+
+    def _require_language(self, language: str) -> None:
+        if language not in self._all_languages:
+            raise KeyError(f"Language '{language}' is not registered. Call set_language() first.")
+
+    def _warn_if_language_missing(self, language: str) -> None:
+        if language not in self._all_languages:
+            logger.warning("Language '%s' is not registered. Did you forget to call set_language()?", language)
+
+    def set_parser(self, language: str, parser: SourceParser) -> None:
+        self._require_language(language)
+        self._parsers[language] = parser
+
+    def get_parser(self, language: str) -> SourceParser | None:
+        self._warn_if_language_missing(language)
+        return self._parsers.get(language)
+
+    def has_parser(self, language: str) -> bool:
+        self._warn_if_language_missing(language)
+        return language in self._parsers
+
+    def remove_parser(self, language: str) -> None:
+        self._warn_if_language_missing(language)
+        self._parsers.pop(language, None)
+
+    def set_resolver(self, language: str, resolver: Resolver) -> None:
+        self._require_language(language)
+        self._resolvers[language] = resolver
+
+    def get_resolver(self, language: str) -> Resolver | None:
+        self._warn_if_language_missing(language)
+        return self._resolvers.get(language)
+
+    def has_resolver(self, language: str) -> bool:
+        self._warn_if_language_missing(language)
+        return language in self._resolvers
+
+    def remove_resolver(self, language: str) -> None:
+        self._warn_if_language_missing(language)
+        self._resolvers.pop(language, None)
+
+    def set_linker(self, language: str, linker: Linker) -> None:
+        self._require_language(language)
+        self._linkers[language] = linker
+
+    def get_linker(self, language: str) -> Linker | None:
+        self._warn_if_language_missing(language)
+        return self._linkers.get(language)
+
+    def has_linker(self, language: str) -> bool:
+        self._warn_if_language_missing(language)
+        return language in self._linkers
+
+    def remove_linker(self, language: str) -> None:
+        self._warn_if_language_missing(language)
+        self._linkers.pop(language, None)
+
+    def set_symbol_cache(self, cache: SymbolCache) -> None:
+        self._require_language(cache.language)
+        self.symbol_caches[cache.language] = cache
+
+    def get_symbol_cache(self, language: str) -> SymbolCache | None:
+        self._warn_if_language_missing(language)
+        return self.symbol_caches.get(language)
+
+    def has_symbol_cache(self, language: str) -> bool:
+        self._warn_if_language_missing(language)
+        return language in self.symbol_caches
+
+    def remove_symbol_cache(self, language: str) -> None:
+        self._warn_if_language_missing(language)
+        self.symbol_caches.pop(language, None)
+
+    def reset(
+        self,
+        include_languages: bool = True,
+        include_file_extensions: bool = True,
+        include_symbol_caches: bool = True,
+    ) -> None:
+        if include_languages:
+            self._selected_languages = set(self._all_languages)
+        if include_file_extensions:
+            self._selected_file_extensions = set(self._all_file_extensions)
+        if include_symbol_caches:
+            self.symbol_caches = {}

deproc_core-0.1.0/deproc/core/discovery.py

@@ -0,0 +1,23 @@
+import fnmatch
+import os
+from .context import Context
+
+def _match_any(name: str, patterns: set[str]) -> bool:
+    return any(fnmatch.fnmatch(name, p) for p in patterns)
+
+def find_source_files(context: Context) -> list[str]:
+    root = context.base_path
+    extension_set = set(context.selected_file_extensions)
+    skip_dirs = context.skip_paths
+    if not extension_set:
+        return []
+
+    matches: list[str] = []
+    for dirpath, dirnames, filenames in os.walk(root):
+        dirnames[:] = [d for d in dirnames if not _match_any(d, skip_dirs)]
+        for f in filenames:
+            if any(f.lower().endswith(ext) for ext in extension_set):
+                matches.append(os.path.join(dirpath, f))
+
+    matches.sort()
+    return matches

deproc_core-0.1.0/deproc/core/interfaces/__init__.py

@@ -0,0 +1,11 @@
+from .linker import Linker
+from .parser import SourceParser
+from .resolver import Resolver
+from .symbol_cache import SymbolCache
+
+__all__ = [
+    "Linker",
+    "Resolver",
+	"SourceParser",
+    "SymbolCache",
+]

deproc_core-0.1.0/deproc/core/interfaces/linker.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Protocol, TypeVar, runtime_checkable
+
+if TYPE_CHECKING:
+    from ..context import Context
+
+from .parser.models import SourceFile, Node
+
+T_In = TypeVar("T_In", bound=list[SourceFile])
+T_Out = TypeVar("T_Out", bound=list[Node])
+
+@runtime_checkable
+class Linker(Protocol[T_In, T_Out]):
+    def link_files(self, nodes: T_In, context: Context) -> T_Out:
+        ...

deproc_core-0.1.0/deproc/core/interfaces/parser/__init__.py

@@ -0,0 +1,5 @@
+from .base import SourceParser
+
+__all__ = [
+    "SourceParser"
+]

deproc_core-0.1.0/deproc/core/interfaces/parser/base.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Protocol, runtime_checkable
+
+if TYPE_CHECKING:
+    from .models import SourceFile
+    from ...context import Context
+
+@runtime_checkable
+class SourceParser(Protocol):
+    def parse_file(self, file_path: str, context: Context) -> SourceFile:
+        ...

deproc_core-0.1.0/deproc/core/interfaces/parser/models.py

@@ -0,0 +1,142 @@
+"""
+Provisional data models for the parser interface.
+Please use these models either directly in the plugin implementations or as a reference for defining plugin-specific models.
+"""
+import hashlib
+from dataclasses import dataclass, field
+from uuid import NAMESPACE_URL, UUID, uuid4, uuid5
+
+type SymbolID = str
+
+def generate_id() -> SymbolID:
+    return uuid4().hex
+
+@dataclass(kw_only=True)
+class Entity:
+    id: str | None = None
+    parent_id: str | None = None
+
+    def __post_init__(self):
+        if self.id is not None:
+            return
+        self.id = self._compute_id()
+
+    def _compute_id(self) -> str:
+        parent_id = getattr(self, "parent_id", None)
+        source_range = getattr(self, "source_range", None)
+        if parent_id and source_range:
+            namespace = UUID(hex=parent_id)
+            name = f"{type(self).__qualname__}:{source_range.lineno}:{source_range.end_lineno}:{source_range.col_offset}:{source_range.end_col_offset}"
+            return uuid5(namespace, name).hex
+        return uuid4().hex
+
+@dataclass(kw_only=True)
+class SourceRange:
+    lineno: int
+    end_lineno: int
+    col_offset: int
+    end_col_offset: int
+    source_id: str | None = None
+
+@dataclass
+class Docstring:
+    docstring_range: SourceRange | None
+
+@dataclass
+class Signature:
+    signature_range: SourceRange
+    arguments_range: SourceRange | None
+    return_type_range: SourceRange | None
+
+@dataclass
+class Annotation:
+    source_range: SourceRange
+    name: str
+
+@dataclass
+class ImportStatement(Entity):
+    source_range: SourceRange
+    type: str
+
+@dataclass
+class Argument:
+    name: str
+    source_range: SourceRange
+    default_value: str | None
+    type_annotation: str | None
+
+@dataclass(kw_only=True)
+class FunctionLike(Docstring, Entity):
+    name: str
+    fqn: str
+    source_range: SourceRange
+    type: str = field(default="FUNCTION")
+    signature: Signature
+
+@dataclass
+class SimpleBinding:
+    name: str
+    fqn: str
+
+@dataclass
+class ComplexBinding:
+    source_range: SourceRange | None
+
+@dataclass(kw_only=True)
+class VariableDeclaration(Entity):
+    type: str = field(default="VARIABLE")
+    source_range: SourceRange
+    variable_binding: SimpleBinding | ComplexBinding
+    value_range: SourceRange | None
+    type_annotation: SourceRange | None
+    modifiers: list[str] = field(default_factory=list)
+
+@dataclass(kw_only=True)
+class TypeDefinition(Docstring, Entity):
+    name: str
+    fqn: str
+    source_range: SourceRange
+    type: str = field(default="TYPE_DEFINITION")
+    annotations: list[Annotation] = field(default_factory=list)
+    inherits: list[str] = field(default_factory=list)
+    method_ids: list[str] = field(default_factory=list)
+    inner_type_ids: list[str] = field(default_factory=list)
+    property_ids: list[str] = field(default_factory=list)
+    visibility: str | None
+
+@dataclass
+class ControlFlowBlock(Entity):
+    branch: str
+    source_range: SourceRange
+    condition_range: SourceRange | None
+    import_stmt_ids: list[SymbolID] = field(default_factory=list)
+    type_ids: list[SymbolID] = field(default_factory=list)
+    function_ids: list[SymbolID] = field(default_factory=list)
+    variable_ids: list[SymbolID] = field(default_factory=list)
+    nested_group_ids: list[SymbolID] = field(default_factory=list)
+
+@dataclass
+class ControlFlowGroup(Entity):
+    group_type: str
+    source_range: SourceRange
+    block_ids: list[SymbolID] = field(default_factory=list)
+
+@dataclass
+class Node(Entity):
+    path: str
+
+    def _compute_id(self) -> str:
+        return uuid5(NAMESPACE_URL, f"file://{self.path}").hex
+
+@dataclass(kw_only=True)
+class SourceFile(Docstring, Node):
+    import_stmt_ids: list[SymbolID] = field(default_factory=list)
+    type_ids: list[SymbolID] = field(default_factory=list)
+    function_ids: list[SymbolID] = field(default_factory=list)
+    variable_ids: list[SymbolID] = field(default_factory=list)
+    control_flow_group_ids: list[SymbolID] = field(default_factory=list)
+    source: str
+
+    def _compute_id(self) -> str:
+        h = hashlib.sha256(self.source.encode()).hexdigest()[:16]
+        return uuid5(NAMESPACE_URL, f"file://{self.path}#{h}").hex

deproc_core-0.1.0/deproc/core/interfaces/resolver.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+from typing import (
+    Any,
+    Protocol,
+    TypeVar,
+    runtime_checkable
+)
+
+TOut = TypeVar("TOut")
+
+@runtime_checkable
+class Resolver(Protocol[TOut]):
+    def resolve(self, *args: Any, **kwargs: Any) -> TOut:
+        ...
+
+__all__ = ["Resolver"]

deproc_core-0.1.0/deproc/core/interfaces/symbol_cache.py

@@ -0,0 +1,20 @@
+from typing import(
+    Any,
+    Protocol, 
+    TypeVar, 
+    runtime_checkable
+)
+
+TCache = TypeVar("TCache")
+TReturn = TypeVar("TReturn")
+
+@runtime_checkable
+class SymbolCache(Protocol[TCache, TReturn]):
+    language: str
+    cache: TCache
+
+    def get(self, *args: Any, **kwargs: Any) -> TReturn:
+        ...
+
+    def set(self, *args: Any, **kwargs: Any) -> None:
+        ...

deproc_core-0.1.0/deproc/core/runtime/__init__.py

@@ -0,0 +1,7 @@
+from .registries import (
+    EntityRegistry
+)
+
+__all__ = [
+    "EntityRegistry"
+]

deproc_core-0.1.0/deproc/core/runtime/registries/__init__.py

@@ -0,0 +1,5 @@
+from .entity import EntityRegistry
+
+__all__ = [
+    "EntityRegistry"
+]

deproc_core-0.1.0/deproc/core/runtime/registries/entity.py

@@ -0,0 +1,42 @@
+from collections import defaultdict
+from dataclasses import dataclass, field
+from ...interfaces.parser.models import (
+    Entity,
+    SymbolID,
+)
+
+@dataclass
+class EntityRegistry:
+    entities: dict[SymbolID, Entity] = field(default_factory=dict)
+    fqn_to_ids: dict[str, set[SymbolID]] = field(default_factory=lambda: defaultdict(set))
+
+    def add(self, entity: Entity) -> None:
+        self.entities[entity.id] = entity
+        fqn = getattr(entity, "fqn", None)
+        if fqn:
+            self.fqn_to_ids[fqn].add(entity.id)
+
+    def add_all(self, entities: list[Entity]) -> None:
+        for entity in entities:
+            self.add(entity)
+
+    def remove(self, entity_id: SymbolID) -> None:
+        entity = self.entities.pop(entity_id, None)
+        if entity is not None:
+            fqn = getattr(entity, "fqn", None)
+            if fqn and entity_id in self.fqn_to_ids.get(fqn, set()):
+                self.fqn_to_ids[fqn].discard(entity_id)
+                if not self.fqn_to_ids[fqn]:
+                    del self.fqn_to_ids[fqn]
+
+    def get_ids_by_fqn(self, fqn: str) -> set[SymbolID]:
+        return set(self.fqn_to_ids.get(fqn, set()))
+
+    def values(self):
+        return self.entities.values()
+
+    def get(self, entity_id: SymbolID, default=None):
+        return self.entities.get(entity_id, default)
+
+    def __contains__(self, entity_id: SymbolID) -> bool:
+        return entity_id in self.entities

deproc_core-0.1.0/deproc_core.egg-info/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: deproc-core
+Version: 0.1.0
+Summary: Language-agnostic core contracts and runtime for deproc plugins.
+Author-email: Gurveer Singh Virk <gurveervirk.15517@gmail.com>
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/gurveervirk/deproc
+Project-URL: Repository, https://github.com/gurveervirk/deproc
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10

deproc_core-0.1.0/deproc_core.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+pyproject.toml
+deproc/core/__init__.py
+deproc/core/context.py
+deproc/core/discovery.py
+deproc/core/interfaces/__init__.py
+deproc/core/interfaces/linker.py
+deproc/core/interfaces/resolver.py
+deproc/core/interfaces/symbol_cache.py
+deproc/core/interfaces/parser/__init__.py
+deproc/core/interfaces/parser/base.py
+deproc/core/interfaces/parser/models.py
+deproc/core/runtime/__init__.py
+deproc/core/runtime/registries/__init__.py
+deproc/core/runtime/registries/entity.py
+deproc_core.egg-info/PKG-INFO
+deproc_core.egg-info/SOURCES.txt
+deproc_core.egg-info/dependency_links.txt
+deproc_core.egg-info/top_level.txt
+tests/test_context.py
+tests/test_discovery.py
+tests/test_entity_registry.py
+tests/test_models.py

deproc_core-0.1.0/deproc_core.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

deproc_core-0.1.0/deproc_core.egg-info/top_level.txt

@@ -0,0 +1 @@
+deproc

deproc_core-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "deproc-core"
+version = "0.1.0"
+description = "Language-agnostic core contracts and runtime for deproc plugins."
+authors = [
+    { name = "Gurveer Singh Virk", email = "gurveervirk.15517@gmail.com" }
+]
+license = {text = "Apache-2.0"}
+requires-python = ">=3.10"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries",
+]
+
+[project.urls]
+Homepage = "https://github.com/gurveervirk/deproc"
+Repository = "https://github.com/gurveervirk/deproc"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["deproc.core*"]

deproc_core-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

deproc_core-0.1.0/tests/test_context.py

@@ -0,0 +1,307 @@
+import pytest
+from deproc.core.context import Context
+from unittest.mock import MagicMock
+
+class TestSetLanguage:
+    def test_set_language_adds_to_selected(self):
+        ctx = Context()
+        ctx.set_language("python", [".py", ".pyi"], aliases=["py"])
+        assert ctx.selected_languages == {"python"}
+        assert ctx.selected_file_extensions == {".py", ".pyi"}
+
+    def test_set_language_normalizes_extension(self):
+        ctx = Context()
+        ctx.set_language("python", ["py", "pyi"])
+        assert ctx.selected_file_extensions == {".py", ".pyi"}
+
+    def test_set_language_normalizes_language(self):
+        ctx = Context()
+        ctx.set_language("Python", [".py"])
+        assert ctx.selected_languages == {"python"}
+
+    def test_set_language_without_aliases(self):
+        ctx = Context()
+        ctx.set_language("python", [".py"])
+        assert ctx.selected_languages == {"python"}
+
+    def test_multiple_languages(self):
+        ctx = Context()
+        ctx.set_language("python", [".py"])
+        ctx.set_language("javascript", [".js"])
+        assert ctx.selected_languages == {"python", "javascript"}
+        assert ctx.selected_file_extensions == {".py", ".js"}
+
+class TestSelectLanguages:
+    def setup_method(self):
+        self.ctx = Context()
+        self.ctx.set_language("python", [".py"], aliases=["py"])
+        self.ctx.set_language("javascript", [".js"])
+
+    def test_exclude_language(self):
+        self.ctx.select_languages(["!python"])
+        assert self.ctx.selected_languages == {"javascript"}
+
+    def test_include_language(self):
+        self.ctx.select_languages(["!python"])
+        self.ctx.select_languages(["python"])
+        assert self.ctx.selected_languages == {"python", "javascript"}
+
+    def test_select_by_alias(self):
+        self.ctx.select_languages(["!python"])
+        self.ctx.select_languages(["py"])
+        assert "python" in self.ctx.selected_languages
+
+    def test_unknown_language_ignored(self):
+        self.ctx.select_languages(["!python"])
+        self.ctx.select_languages(["unknown"])
+        assert self.ctx.selected_languages == {"javascript"}
+
+class TestSelectFileExtensions:
+    def setup_method(self):
+        self.ctx = Context()
+        self.ctx.set_language("python", [".py", ".pyi"])
+
+    def test_exclude_extension(self):
+        self.ctx.select_file_extensions(["!.py"])
+        assert self.ctx.selected_file_extensions == {".pyi"}
+
+    def test_include_extension(self):
+        self.ctx.select_file_extensions(["!.py"])
+        self.ctx.select_file_extensions([".py"])
+        assert self.ctx.selected_file_extensions == {".py", ".pyi"}
+
+    def test_unknown_extension_ignored(self):
+        self.ctx.select_file_extensions(["!.py"])
+        self.ctx.select_file_extensions([".unknown"])
+        assert self.ctx.selected_file_extensions == {".pyi"}
+
+class TestSetParser:
+    def setup_method(self):
+        self.ctx = Context()
+        self.ctx.set_language("python", [".py"])
+
+    def test_set_and_get_parser(self):
+        self.ctx.set_parser("python", "fake_parser")
+        assert self.ctx.get_parser("python") == "fake_parser"
+
+    def test_has_parser(self):
+        assert not self.ctx.has_parser("python")
+        self.ctx.set_parser("python", "fake_parser")
+        assert self.ctx.has_parser("python")
+
+    def test_remove_parser(self):
+        self.ctx.set_parser("python", "fake_parser")
+        self.ctx.remove_parser("python")
+        assert not self.ctx.has_parser("python")
+
+    def test_set_parser_raises_for_unregistered_language(self):
+        with pytest.raises(KeyError, match="not registered"):
+            self.ctx.set_parser("unknown", "fake_parser")
+
+    def test_get_parser_missing_language_logs_warning(self, caplog):
+        caplog.set_level("WARNING")
+        self.ctx.get_parser("unknown")
+        assert "not registered" in caplog.text
+
+    def test_has_parser_missing_language_logs_warning(self, caplog):
+        caplog.set_level("WARNING")
+        self.ctx.has_parser("unknown")
+        assert "not registered" in caplog.text
+
+class TestSetResolver:
+    def setup_method(self):
+        self.ctx = Context()
+        self.ctx.set_language("python", [".py"])
+
+    def test_set_and_get_resolver(self):
+        self.ctx.set_resolver("python", "fake_resolver")
+        assert self.ctx.get_resolver("python") == "fake_resolver"
+
+    def test_has_resolver(self):
+        assert not self.ctx.has_resolver("python")
+        self.ctx.set_resolver("python", "fake_resolver")
+        assert self.ctx.has_resolver("python")
+
+    def test_remove_resolver(self):
+        self.ctx.set_resolver("python", "fake_resolver")
+        self.ctx.remove_resolver("python")
+        assert not self.ctx.has_resolver("python")
+
+    def test_set_resolver_raises_for_unregistered_language(self):
+        with pytest.raises(KeyError, match="not registered"):
+            self.ctx.set_resolver("unknown", "fake_resolver")
+
+    def test_get_resolver_missing_language_logs_warning(self, caplog):
+        caplog.set_level("WARNING")
+        self.ctx.get_resolver("unknown")
+        assert "not registered" in caplog.text
+
+class TestSetLinker:
+    def setup_method(self):
+        self.ctx = Context()
+        self.ctx.set_language("python", [".py"])
+
+    def test_set_and_get_linker(self):
+        self.ctx.set_linker("python", "fake_linker")
+        assert self.ctx.get_linker("python") == "fake_linker"
+
+    def test_has_linker(self):
+        assert not self.ctx.has_linker("python")
+        self.ctx.set_linker("python", "fake_linker")
+        assert self.ctx.has_linker("python")
+
+    def test_remove_linker(self):
+        self.ctx.set_linker("python", "fake_linker")
+        self.ctx.remove_linker("python")
+        assert not self.ctx.has_linker("python")
+
+    def test_set_linker_raises_for_unregistered_language(self):
+        with pytest.raises(KeyError, match="not registered"):
+            self.ctx.set_linker("unknown", "fake_linker")
+
+    def test_get_linker_missing_language_logs_warning(self, caplog):
+        caplog.set_level("WARNING")
+        self.ctx.get_linker("unknown")
+        assert "not registered" in caplog.text
+
+class TestSetSymbolCache:
+    def setup_method(self):
+        self.ctx = Context()
+        self.ctx.set_language("python", [".py"])
+        self.cache = MagicMock()
+        self.cache.language = "python"
+
+    def test_set_and_get_symbol_cache(self):
+        self.ctx.set_symbol_cache(self.cache)
+        assert self.ctx.get_symbol_cache("python") is self.cache
+
+    def test_has_symbol_cache(self):
+        assert not self.ctx.has_symbol_cache("python")
+        self.ctx.set_symbol_cache(self.cache)
+        assert self.ctx.has_symbol_cache("python")
+
+    def test_remove_symbol_cache(self):
+        self.ctx.set_symbol_cache(self.cache)
+        self.ctx.remove_symbol_cache("python")
+        assert not self.ctx.has_symbol_cache("python")
+
+    def test_set_symbol_cache_raises_for_unregistered_language(self):
+        cache = MagicMock()
+        cache.language = "unknown"
+        with pytest.raises(KeyError, match="not registered"):
+            self.ctx.set_symbol_cache(cache)
+
+    def test_get_symbol_cache_missing_language_logs_warning(self, caplog):
+        caplog.set_level("WARNING")
+        self.ctx.get_symbol_cache("unknown")
+        assert "not registered" in caplog.text
+
+class TestCopyFrom:
+    def test_copy_preserves_language_config(self):
+        ctx = Context()
+        ctx.set_language("python", [".py"], aliases=["py"])
+        ctx.set_parser("python", "fake_parser")
+        copy = Context(copy_from=ctx)
+        assert copy.selected_languages == {"python"}
+        assert copy.selected_file_extensions == {".py"}
+        assert copy.get_parser("python") == "fake_parser"
+
+    def test_copy_is_independent(self):
+        ctx = Context()
+        ctx.set_language("python", [".py"])
+        ctx.set_parser("python", "fake_parser")
+        copy = Context(copy_from=ctx)
+        copy.set_parser("python", "different_parser")
+        assert ctx.get_parser("python") == "fake_parser"
+        assert copy.get_parser("python") == "different_parser"
+
+    def test_copy_by_default_empty(self):
+        ctx = Context()
+        assert ctx.selected_languages == set()
+        assert ctx.selected_file_extensions == set()
+
+class TestReset:
+    def test_reset_restores_all_languages(self):
+        ctx = Context()
+        ctx.set_language("python", [".py"])
+        ctx.set_language("javascript", [".js"])
+        ctx.select_languages(["!python"])
+        ctx.reset()
+        assert ctx.selected_languages == {"python", "javascript"}
+
+    def test_reset_restores_all_file_extensions(self):
+        ctx = Context()
+        ctx.set_language("python", [".py", ".pyi"])
+        ctx.select_file_extensions(["!.py"])
+        ctx.reset()
+        assert ctx.selected_file_extensions == {".py", ".pyi"}
+
+    def test_reset_skips_languages_when_flag_false(self):
+        ctx = Context()
+        ctx.set_language("python", [".py"])
+        ctx.select_languages(["!python"])
+        ctx.reset(include_languages=False)
+        assert ctx.selected_languages == set()
+
+class TestSkipPaths:
+    def test_default_is_empty(self):
+        ctx = Context()
+        assert ctx.skip_paths == set()
+
+    def test_set_skip_paths(self):
+        ctx = Context()
+        ctx.set_skip_paths({".venv", ".git"})
+        assert ctx.skip_paths == {".venv", ".git"}
+
+    def test_set_skip_paths_replaces(self):
+        ctx = Context()
+        ctx.set_skip_paths({".venv"})
+        ctx.set_skip_paths({".git"})
+        assert ctx.skip_paths == {".git"}
+
+    def test_copy_preserves_skip_paths(self):
+        ctx = Context()
+        ctx.set_skip_paths({".venv", "__pycache__"})
+        copy = Context(copy_from=ctx)
+        assert copy.skip_paths == {".venv", "__pycache__"}
+
+    def test_copy_is_independent(self):
+        ctx = Context()
+        ctx.set_skip_paths({".venv"})
+        copy = Context(copy_from=ctx)
+        copy.set_skip_paths({".git"})
+        assert ctx.skip_paths == {".venv"}
+        assert copy.skip_paths == {".git"}
+
+class TestEmptyContext:
+    def test_empty_selected_languages(self):
+        ctx = Context()
+        assert ctx.selected_languages == set()
+
+    def test_empty_selected_file_extensions(self):
+        ctx = Context()
+        assert ctx.selected_file_extensions == set()
+
+    def test_get_parser_returns_none(self):
+        ctx = Context()
+        assert ctx.get_parser("anything") is None
+
+    def test_has_parser_returns_false(self):
+        ctx = Context()
+        assert not ctx.has_parser("anything")
+
+    def test_remove_parser_noop(self):
+        ctx = Context()
+        ctx.remove_parser("anything")
+
+    def test_get_resolver_returns_none(self):
+        ctx = Context()
+        assert ctx.get_resolver("anything") is None
+
+    def test_get_linker_returns_none(self):
+        ctx = Context()
+        assert ctx.get_linker("anything") is None
+
+    def test_get_symbol_cache_returns_none(self):
+        ctx = Context()
+        assert ctx.get_symbol_cache("anything") is None

deproc_core-0.1.0/tests/test_discovery.py

@@ -0,0 +1,59 @@
+from deproc.core.context import Context
+from deproc.core.discovery import find_source_files
+from pathlib import Path
+
+class TestFindSourceFiles:
+    def test_skips_dirs_in_skip_paths(self, tmp_path):
+        (tmp_path / "a.py").write_text("")
+        (tmp_path / ".venv").mkdir()
+        (tmp_path / ".venv" / "b.py").write_text("")
+        (tmp_path / ".git").mkdir()
+        (tmp_path / ".git" / "c.py").write_text("")
+
+        ctx = Context(base_path=str(tmp_path))
+        ctx.set_language("python", [".py"])
+        ctx.set_skip_paths({".venv", ".git"})
+
+        files = find_source_files(ctx)
+        paths = {Path(f).name for f in files}
+        assert paths == {"a.py"}
+
+    def test_empty_skip_paths_finds_all(self, tmp_path):
+        (tmp_path / "a.py").write_text("")
+        (tmp_path / ".venv").mkdir()
+        (tmp_path / ".venv" / "b.py").write_text("")
+
+        ctx = Context(base_path=str(tmp_path))
+        ctx.set_language("python", [".py"])
+
+        files = find_source_files(ctx)
+        assert len(files) == 2
+
+    def test_glob_pattern_in_skip_paths(self, tmp_path):
+        (tmp_path / ".venv").mkdir()
+        (tmp_path / ".venv" / "b.py").write_text("")
+        (tmp_path / ".venv2").mkdir()
+        (tmp_path / ".venv2" / "c.py").write_text("")
+        (tmp_path / "a.py").write_text("")
+
+        ctx = Context(base_path=str(tmp_path))
+        ctx.set_language("python", [".py"])
+        ctx.set_skip_paths({".venv*"})
+
+        files = find_source_files(ctx)
+        paths = {Path(f).name for f in files}
+        assert paths == {"a.py"}
+
+    def test_glob_pattern_does_not_affect_non_matching(self, tmp_path):
+        (tmp_path / ".venv").mkdir()
+        (tmp_path / ".venv" / "b.py").write_text("")
+        (tmp_path / "vendor").mkdir()
+        (tmp_path / "vendor" / "a.py").write_text("")
+
+        ctx = Context(base_path=str(tmp_path))
+        ctx.set_language("python", [".py"])
+        ctx.set_skip_paths({"vendor*"})
+
+        files = find_source_files(ctx)
+        paths = {Path(f).name for f in files}
+        assert paths == {"b.py"}

deproc_core-0.1.0/tests/test_entity_registry.py

@@ -0,0 +1,104 @@
+"""Tests for EntityRegistry."""
+from dataclasses import dataclass
+from deproc.core.runtime.registries.entity import EntityRegistry
+from deproc.core.interfaces.parser.models import Entity
+
+@dataclass(kw_only=True)
+class _FakeFqnEntity(Entity):
+    fqn: str
+
+class TestEntityRegistryValues:
+    def test_empty_registry_values(self):
+        registry = EntityRegistry()
+        assert list(registry.values()) == []
+
+    def test_values_after_add(self):
+        registry = EntityRegistry()
+        e1 = Entity(id="id_1")
+        e2 = Entity(id="id_2")
+        registry.add(e1)
+        registry.add(e2)
+        assert list(registry.values()) == [e1, e2]
+
+    def test_values_after_add_all(self):
+        registry = EntityRegistry()
+        e1 = Entity(id="id_1")
+        e2 = Entity(id="id_2")
+        registry.add_all([e1, e2])
+        assert list(registry.values()) == [e1, e2]
+
+class TestEntityRegistryGet:
+    def test_get_returns_entity(self):
+        registry = EntityRegistry()
+        e = Entity(id="id_1")
+        registry.add(e)
+        assert registry.get("id_1") is e
+
+    def test_get_missing_returns_none(self):
+        registry = EntityRegistry()
+        assert registry.get("nonexistent") is None
+
+    def test_get_missing_returns_default(self):
+        registry = EntityRegistry()
+        assert registry.get("nonexistent", "fallback") == "fallback"
+
+    def test_get_with_none_default(self):
+        registry = EntityRegistry()
+        assert registry.get("nonexistent", None) is None
+
+    def test_get_default_not_used_when_found(self):
+        registry = EntityRegistry()
+        e = Entity(id="id_1")
+        registry.add(e)
+        assert registry.get("id_1", "fallback") is e
+
+class TestEntityRegistryContains:
+    def test_contains_added(self):
+        registry = EntityRegistry()
+        e = Entity(id="id_1")
+        registry.add(e)
+        assert "id_1" in registry
+
+    def test_not_contains_missing(self):
+        registry = EntityRegistry()
+        assert "nonexistent" not in registry
+
+class TestEntityRegistryFqnMapping:
+    def test_add_entity_with_fqn_updates_mapping(self):
+        registry = EntityRegistry()
+        e = _FakeFqnEntity(id="id_1", fqn="mymodule.MyClass")
+        registry.add(e)
+        assert registry.get_ids_by_fqn("mymodule.MyClass") == {"id_1"}
+
+    def test_add_entity_without_fqn_does_not_update_mapping(self):
+        registry = EntityRegistry()
+        e = Entity(id="id_1")
+        registry.add(e)
+        assert registry.get_ids_by_fqn("anything") == set()
+
+    def test_get_ids_by_fqn_returns_empty_for_missing(self):
+        registry = EntityRegistry()
+        assert registry.get_ids_by_fqn("nonexistent") == set()
+
+    def test_get_ids_by_fqn_multiple_entities_same_fqn(self):
+        registry = EntityRegistry()
+        e1 = _FakeFqnEntity(id="id_1", fqn="mymodule.MyClass")
+        e2 = _FakeFqnEntity(id="id_2", fqn="mymodule.MyClass")
+        registry.add(e1)
+        registry.add(e2)
+        assert registry.get_ids_by_fqn("mymodule.MyClass") == {"id_1", "id_2"}
+
+    def test_remove_entity_cleans_up_fqn_mapping(self):
+        registry = EntityRegistry()
+        e = _FakeFqnEntity(id="id_1", fqn="mymodule.MyClass")
+        registry.add(e)
+        registry.remove("id_1")
+        assert registry.get_ids_by_fqn("mymodule.MyClass") == set()
+        assert "id_1" not in registry
+
+    def test_remove_entity_without_fqn_does_not_error(self):
+        registry = EntityRegistry()
+        e = Entity(id="id_1")
+        registry.add(e)
+        registry.remove("id_1")
+        assert "id_1" not in registry

deproc_core-0.1.0/tests/test_models.py

@@ -0,0 +1,173 @@
+"""Tests for deterministic entity ID generation."""
+from dataclasses import dataclass
+from uuid import uuid4
+from deproc.core.interfaces.parser.models import (
+    Entity,
+    ImportStatement,
+    Node,
+    SourceFile,
+    SourceRange,
+    SimpleBinding,
+    VariableDeclaration,
+)
+
+_PARENT = uuid4().hex
+_OTHER_PARENT = uuid4().hex
+
+@dataclass(kw_only=True)
+class _EntityWithSource(Entity):
+    source_range: SourceRange
+
+class TestEntityDeterministicId:
+    def test_same_parent_and_source_range_produces_same_id(self):
+        sr = SourceRange(lineno=10, end_lineno=20, col_offset=1, end_col_offset=30)
+        e1 = _EntityWithSource(parent_id=_PARENT, source_range=sr)
+        e2 = _EntityWithSource(parent_id=_PARENT, source_range=sr)
+        assert e1.id == e2.id
+
+    def test_different_parent_id_produces_different_id(self):
+        sr = SourceRange(lineno=10, end_lineno=20, col_offset=1, end_col_offset=30)
+        e1 = _EntityWithSource(parent_id=_PARENT, source_range=sr)
+        e2 = _EntityWithSource(parent_id=_OTHER_PARENT, source_range=sr)
+        assert e1.id != e2.id
+
+    def test_different_source_range_produces_different_id(self):
+        sr1 = SourceRange(lineno=1, end_lineno=5, col_offset=0, end_col_offset=10)
+        sr2 = SourceRange(lineno=2, end_lineno=5, col_offset=0, end_col_offset=10)
+        e1 = _EntityWithSource(parent_id=_PARENT, source_range=sr1)
+        e2 = _EntityWithSource(parent_id=_PARENT, source_range=sr2)
+        assert e1.id != e2.id
+
+    def test_different_subclass_types_produce_different_ids(self):
+        sr = SourceRange(lineno=1, end_lineno=1, col_offset=0, end_col_offset=5)
+
+        @dataclass(kw_only=True)
+        class SubA(Entity):
+            source_range: SourceRange
+
+        @dataclass(kw_only=True)
+        class SubB(Entity):
+            source_range: SourceRange
+
+        a = SubA(parent_id=_PARENT, source_range=sr)
+        b = SubB(parent_id=_PARENT, source_range=sr)
+        assert a.id != b.id
+
+    def test_entity_without_parent_id_is_not_deterministic(self):
+        e1 = _EntityWithSource(
+            parent_id=None,
+            source_range=SourceRange(lineno=1, end_lineno=1, col_offset=0, end_col_offset=5),
+        )
+        e2 = _EntityWithSource(
+            parent_id=None,
+            source_range=SourceRange(lineno=1, end_lineno=1, col_offset=0, end_col_offset=5),
+        )
+        assert e1.id != e2.id
+
+    def test_entity_without_source_range_is_not_deterministic(self):
+        e1 = Entity(parent_id=_PARENT)
+        e2 = Entity(parent_id=_PARENT)
+        assert e1.id != e2.id
+
+    def test_explicit_id_is_preserved(self):
+        e = Entity(id="my-explicit-id")
+        assert e.id == "my-explicit-id"
+
+    def test_explicit_id_skips_computation(self):
+        sr = SourceRange(lineno=1, end_lineno=1, col_offset=0, end_col_offset=5)
+        e = _EntityWithSource(id="explicit", parent_id=_PARENT, source_range=sr)
+        assert e.id == "explicit"
+
+class TestNodeDeterministicId:
+    def test_same_path_produces_same_id(self):
+        n1 = Node(path="src/main.py")
+        n2 = Node(path="src/main.py")
+        assert n1.id == n2.id
+
+    def test_different_path_produces_different_id(self):
+        n1 = Node(path="src/main.py")
+        n2 = Node(path="src/utils.py")
+        assert n1.id != n2.id
+
+    def test_node_id_is_32_hex_chars(self):
+        n = Node(path="src/main.py")
+        assert isinstance(n.id, str)
+        assert len(n.id) == 32
+
+    def test_source_file_id_is_deterministic(self):
+        sf1 = SourceFile(path="foo/bar.py", docstring_range=None, source="")
+        sf2 = SourceFile(path="foo/bar.py", docstring_range=None, source="")
+        assert sf1.id == sf2.id
+
+    def test_source_file_with_different_path_has_different_id(self):
+        sf1 = SourceFile(path="foo/bar.py", docstring_range=None, source="")
+        sf2 = SourceFile(path="foo/baz.py", docstring_range=None, source="")
+        assert sf1.id != sf2.id
+
+    def test_node_uses_path_not_parent_id(self):
+        @dataclass(kw_only=True)
+        class NodeSubclass(Node):
+            source_range: SourceRange
+
+        sr = SourceRange(lineno=1, end_lineno=1, col_offset=0, end_col_offset=5)
+        n1 = NodeSubclass(path="foo.py", parent_id=_PARENT, source_range=sr)
+        n2 = NodeSubclass(path="foo.py", parent_id=_OTHER_PARENT, source_range=sr)
+        assert n1.id == n2.id
+
+    def test_source_file_different_source_different_id(self):
+        sf1 = SourceFile(path="foo.py", docstring_range=None, source="a")
+        sf2 = SourceFile(path="foo.py", docstring_range=None, source="b")
+        assert sf1.id != sf2.id
+
+    def test_source_file_same_source_same_id(self):
+        sf1 = SourceFile(path="foo.py", docstring_range=None, source="hello")
+        sf2 = SourceFile(path="foo.py", docstring_range=None, source="hello")
+        assert sf1.id == sf2.id
+
+class TestSourceRangeSourceId:
+    def test_source_id_defaults_to_none(self):
+        sr = SourceRange(lineno=1, end_lineno=10, col_offset=0, end_col_offset=5)
+        assert sr.source_id is None
+
+    def test_source_id_set_via_keyword(self):
+        sr = SourceRange(lineno=1, end_lineno=10, col_offset=0, end_col_offset=5, source_id="src123")
+        assert sr.source_id == "src123"
+
+    def test_source_id_not_in_entity_id_computation(self):
+        sr1 = SourceRange(lineno=5, end_lineno=5, col_offset=0, end_col_offset=10, source_id="file_a")
+        sr2 = SourceRange(lineno=5, end_lineno=5, col_offset=0, end_col_offset=10, source_id="file_b")
+        e1 = _EntityWithSource(parent_id=_PARENT, source_range=sr1)
+        e2 = _EntityWithSource(parent_id=_PARENT, source_range=sr2)
+        assert e1.id == e2.id
+
+    def test_source_id_mutable(self):
+        sr = SourceRange(lineno=1, end_lineno=1, col_offset=0, end_col_offset=0)
+        assert sr.source_id is None
+        sr.source_id = "assigned_later"
+        assert sr.source_id == "assigned_later"
+
+class TestConcreteSubclassDeterminism:
+    def test_variable_declaration_with_parent_and_source_is_deterministic(self):
+        sr = SourceRange(lineno=5, end_lineno=5, col_offset=0, end_col_offset=10)
+        binding = SimpleBinding(name="x", fqn="mod.x")
+        v1 = VariableDeclaration(
+            parent_id=_PARENT,
+            source_range=sr,
+            variable_binding=binding,
+            value_range=None,
+            type_annotation=None,
+        )
+        v2 = VariableDeclaration(
+            parent_id=_PARENT,
+            source_range=sr,
+            variable_binding=binding,
+            value_range=None,
+            type_annotation=None,
+        )
+        assert v1.id == v2.id
+
+    def test_import_statement_with_parent_and_source_is_deterministic(self):
+        sr = SourceRange(lineno=1, end_lineno=1, col_offset=0, end_col_offset=20)
+        i1 = ImportStatement(type="from_import", parent_id=_PARENT, source_range=sr)
+        i2 = ImportStatement(type="from_import", parent_id=_PARENT, source_range=sr)
+        assert i1.id == i2.id