codeclone 1.1.0__py3-none-any.whl → 1.2.1__py3-none-any.whl

codeclone/__init__.py

@@ -6,7 +6,7 @@ Copyright (c) 2026 Den Rozhnovskiy
 Licensed under the MIT License.
 """
 
-from importlib.metadata import version, PackageNotFoundError
+from importlib.metadata import PackageNotFoundError, version
 
 try:
     __version__ = version("codeclone")

codeclone/baseline.py

@@ -9,32 +9,40 @@ Licensed under the MIT License.
 from __future__ import annotations
 
 import json
+from collections.abc import Mapping
 from pathlib import Path
-from typing import Set
+from typing import Any
 
 
 class Baseline:
-    def __init__(self, path: str):
+    __slots__ = ("blocks", "functions", "path", "python_version")
+
+    def __init__(self, path: str | Path):
         self.path = Path(path)
-        self.functions: Set[str] = set()
-        self.blocks: Set[str] = set()
+        self.functions: set[str] = set()
+        self.blocks: set[str] = set()
+        self.python_version: str | None = None
 
     def load(self) -> None:
         if not self.path.exists():
             return
 
-        data = json.loads(self.path.read_text("utf-8"))
-        self.functions = set(data.get("functions", []))
-        self.blocks = set(data.get("blocks", []))
+        try:
+            data = json.loads(self.path.read_text("utf-8"))
+            self.functions = set(data.get("functions", []))
+            self.blocks = set(data.get("blocks", []))
+            python_version = data.get("python_version")
+            self.python_version = (
+                python_version if isinstance(python_version, str) else None
+            )
+        except json.JSONDecodeError as e:
+            raise ValueError(f"Corrupted baseline file at {self.path}: {e}") from e
 
     def save(self) -> None:
         self.path.parent.mkdir(parents=True, exist_ok=True)
         self.path.write_text(
             json.dumps(
-                {
-                    "functions": sorted(self.functions),
-                    "blocks": sorted(self.blocks),
-                },
+                _baseline_payload(self.functions, self.blocks, self.python_version),
                 indent=2,
                 ensure_ascii=False,
             ),
@@ -42,13 +50,35 @@ class Baseline:
         )
 
     @staticmethod
-    def from_groups(func_groups: dict, block_groups: dict) -> "Baseline":
-        bl = Baseline("")
+    def from_groups(
+        func_groups: Mapping[str, object],
+        block_groups: Mapping[str, object],
+        path: str | Path = "",
+        python_version: str | None = None,
+    ) -> Baseline:
+        bl = Baseline(path)
         bl.functions = set(func_groups.keys())
         bl.blocks = set(block_groups.keys())
+        bl.python_version = python_version
         return bl
 
-    def diff(self, func_groups: dict, block_groups: dict) -> tuple[set, set]:
+    def diff(
+        self, func_groups: Mapping[str, object], block_groups: Mapping[str, object]
+    ) -> tuple[set[str], set[str]]:
         new_funcs = set(func_groups.keys()) - self.functions
         new_blocks = set(block_groups.keys()) - self.blocks
         return new_funcs, new_blocks
+
+
+def _baseline_payload(
+    functions: set[str],
+    blocks: set[str],
+    python_version: str | None,
+) -> dict[str, Any]:
+    payload: dict[str, Any] = {
+        "functions": sorted(functions),
+        "blocks": sorted(blocks),
+    }
+    if python_version:
+        payload["python_version"] = python_version
+    return payload

codeclone/blockhash.py

@@ -11,7 +11,7 @@ from __future__ import annotations
 import ast
 import hashlib
 
-from .normalize import NormalizationConfig, AstNormalizer
+from .normalize import AstNormalizer, NormalizationConfig
 
 
 def stmt_hash(stmt: ast.stmt, cfg: NormalizationConfig) -> str:

codeclone/blocks.py

@@ -15,7 +15,7 @@ from .blockhash import stmt_hash
 from .normalize import NormalizationConfig
 
 
-@dataclass(frozen=True)
+@dataclass(frozen=True, slots=True)
 class BlockUnit:
     block_hash: str
     filepath: str
@@ -42,7 +42,8 @@ def extract_blocks(
 
     blocks: list[BlockUnit] = []
     last_start: int | None = None
-    MIN_LINE_DISTANCE = 5  # suppress overlapping windows
+    # Allow some overlap (50%), but at least 3 lines apart
+    min_line_distance = max(block_size // 2, 3)
 
     for i in range(len(stmt_hashes) - block_size + 1):
         start = getattr(body[i], "lineno", None)
@@ -50,7 +51,7 @@ def extract_blocks(
         if not start or not end:
             continue
 
-        if last_start is not None and start - last_start < MIN_LINE_DISTANCE:
+        if last_start is not None and start - last_start < min_line_distance:
             continue
 
         bh = "|".join(stmt_hashes[i : i + block_size])

codeclone/cache.py

@@ -8,41 +8,178 @@ Licensed under the MIT License.
 
 from __future__ import annotations
 
+import hashlib
+import hmac
 import json
 import os
+import secrets
+from collections.abc import Mapping
 from dataclasses import asdict
 from pathlib import Path
-from typing import Optional
+from typing import TYPE_CHECKING, Any, TypedDict, cast
+
+if TYPE_CHECKING:
+    from .blocks import BlockUnit
+    from .extractor import Unit
+
+from .errors import CacheError
+
+
+class FileStat(TypedDict):
+    mtime_ns: int
+    size: int
+
+
+class UnitDict(TypedDict):
+    qualname: str
+    filepath: str
+    start_line: int
+    end_line: int
+    loc: int
+    stmt_count: int
+    fingerprint: str
+    loc_bucket: str
+
+
+class BlockDict(TypedDict):
+    block_hash: str
+    filepath: str
+    qualname: str
+    start_line: int
+    end_line: int
+    size: int
+
+
+class CacheEntry(TypedDict):
+    stat: FileStat
+    units: list[UnitDict]
+    blocks: list[BlockDict]
+
+
+class CacheData(TypedDict):
+    version: str
+    files: dict[str, CacheEntry]
 
 
 class Cache:
-    def __init__(self, path: str):
+    __slots__ = ("data", "load_warning", "path", "secret")
+    CACHE_VERSION = "1.0"
+
+    def __init__(self, path: str | Path):
         self.path = Path(path)
-        self.data: dict = {"files": {}}
+        self.data: CacheData = {"version": self.CACHE_VERSION, "files": {}}
+        self.secret = self._load_secret()
+        self.load_warning: str | None = None
+
+    def _load_secret(self) -> bytes:
+        """Load or create cache signing secret."""
+        # Store secret in the same directory as the cache file, named .cache_secret
+        # If cache is at ~/.cache/codeclone/cache.json, secret is
+        # ~/.cache/codeclone/.cache_secret
+        secret_path = self.path.parent / ".cache_secret"
+        if secret_path.exists():
+            return secret_path.read_bytes()
+        else:
+            secret = secrets.token_bytes(32)
+            try:
+                self.path.parent.mkdir(parents=True, exist_ok=True)
+                secret_path.write_bytes(secret)
+                # Set restrictive permissions on secret file (Unix only)
+                if os.name == "posix":
+                    secret_path.chmod(0o600)
+            except OSError:
+                pass
+            return secret
+
+    def _sign_data(self, data: Mapping[str, Any]) -> str:
+        """Create HMAC signature of cache data."""
+        # Sort keys for deterministic JSON serialization
+        data_str = json.dumps(data, sort_keys=True)
+        return hmac.new(self.secret, data_str.encode(), hashlib.sha256).hexdigest()
 
     def load(self) -> None:
-        if self.path.exists():
-            self.data = json.loads(self.path.read_text("utf-8"))
+        if not self.path.exists():
+            return
+
+        try:
+            raw = json.loads(self.path.read_text("utf-8"))
+            stored_sig = raw.get("_signature")
+
+            # Extract data without signature for verification
+            data = {k: v for k, v in raw.items() if k != "_signature"}
+
+            # Verify signature
+            expected_sig = self._sign_data(data)
+            if stored_sig != expected_sig:
+                self.load_warning = "Cache signature mismatch; ignoring cache."
+                self.data = {"version": self.CACHE_VERSION, "files": {}}
+                return
+
+            if data.get("version") != self.CACHE_VERSION:
+                self.load_warning = (
+                    "Cache version mismatch "
+                    f"(found {data.get('version')}); ignoring cache."
+                )
+                self.data = {"version": self.CACHE_VERSION, "files": {}}
+                return
+
+            # Basic structure check
+            if not isinstance(data.get("files"), dict):
+                self.load_warning = "Cache format invalid; ignoring cache."
+                self.data = {"version": self.CACHE_VERSION, "files": {}}
+                return
+
+            self.data = cast(CacheData, data)
+            self.load_warning = None
+
+        except (json.JSONDecodeError, ValueError):
+            self.load_warning = "Cache corrupted; ignoring cache."
+            self.data = {"version": self.CACHE_VERSION, "files": {}}
 
     def save(self) -> None:
-        self.path.parent.mkdir(parents=True, exist_ok=True)
-        self.path.write_text(
-            json.dumps(self.data, ensure_ascii=False, indent=2),
-            "utf-8",
-        )
+        try:
+            self.path.parent.mkdir(parents=True, exist_ok=True)
+
+            # Add signature
+            data_with_sig = {**self.data, "_signature": self._sign_data(self.data)}
+
+            self.path.write_text(
+                json.dumps(data_with_sig, ensure_ascii=False, indent=2),
+                "utf-8",
+            )
+        except OSError as e:
+            raise CacheError(f"Failed to save cache: {e}") from e
+
+    def get_file_entry(self, filepath: str) -> CacheEntry | None:
+        entry = self.data["files"].get(filepath)
+
+        if entry is None:
+            return None
+
+        if not isinstance(entry, dict):
+            return None
+
+        required = {"stat", "units", "blocks"}
+        if not required.issubset(entry.keys()):
+            return None
 
-    def get_file_entry(self, filepath: str) -> Optional[dict]:
-        return self.data.get("files", {}).get(filepath)
+        return entry
 
-    def put_file_entry(self, filepath: str, stat_sig: dict, units, blocks) -> None:
-        self.data.setdefault("files", {})[filepath] = {
+    def put_file_entry(
+        self,
+        filepath: str,
+        stat_sig: FileStat,
+        units: list[Unit],
+        blocks: list[BlockUnit],
+    ) -> None:
+        self.data["files"][filepath] = {
             "stat": stat_sig,
-            "units": [asdict(u) for u in units],
-            "blocks": [asdict(b) for b in blocks],
+            "units": cast(list[UnitDict], cast(object, [asdict(u) for u in units])),
+            "blocks": cast(list[BlockDict], cast(object, [asdict(b) for b in blocks])),
         }
 
 
-def file_stat_signature(path: str) -> dict:
+def file_stat_signature(path: str) -> FileStat:
     st = os.stat(path)
     return {
         "mtime_ns": st.st_mtime_ns,

codeclone/cfg.py

@@ -9,48 +9,21 @@ Licensed under the MIT License.
 from __future__ import annotations
 
 import ast
-from dataclasses import dataclass, field
-from typing import Iterable
+from collections.abc import Iterable
+from typing import Protocol, cast
 
+from .cfg_model import CFG, Block
 
-# =========================
-# Core CFG structures
-# =========================
-
-
-@dataclass(eq=False)
-class Block:
-    id: int
-    statements: list[ast.stmt] = field(default_factory=list)
-    successors: set["Block"] = field(default_factory=set)
-    is_terminated: bool = False
-
-    def add_successor(self, block: Block) -> None:
-        self.successors.add(block)
-
-    def __hash__(self) -> int:
-        return hash(self.id)
+__all__ = ["CFG", "CFGBuilder"]
 
-    def __eq__(self, other: object) -> bool:
-        return isinstance(other, Block) and self.id == other.id
+TryStar = getattr(ast, "TryStar", ast.Try)
 
 
-@dataclass
-class CFG:
-    qualname: str
-    blocks: list[Block] = field(default_factory=list)
-
-    entry: Block = field(init=False)
-    exit: Block = field(init=False)
-
-    def __post_init__(self) -> None:
-        self.entry = self.create_block()
-        self.exit = self.create_block()
-
-    def create_block(self) -> Block:
-        block = Block(id=len(self.blocks))
-        self.blocks.append(block)
-        return block
+class _TryLike(Protocol):
+    body: list[ast.stmt]
+    handlers: list[ast.ExceptHandler]
+    orelse: list[ast.stmt]
+    finalbody: list[ast.stmt]
 
 
 # =========================
@@ -59,6 +32,8 @@ class CFG:
 
 
 class CFGBuilder:
+    __slots__ = ("cfg", "current")
+
     def __init__(self) -> None:
         self.cfg: CFG
         self.current: Block
@@ -107,6 +82,20 @@ class CFGBuilder:
             case ast.For():
                 self._visit_for(stmt)
 
+            case ast.AsyncFor():
+                self._visit_for(stmt)  # Structure is identical to For
+
+            case ast.Try():
+                self._visit_try(cast(_TryLike, stmt))
+            case _ if TryStar is not None and isinstance(stmt, TryStar):
+                self._visit_try(cast(_TryLike, stmt))
+
+            case ast.With() | ast.AsyncWith():
+                self._visit_with(stmt)
+
+            case ast.Match():
+                self._visit_match(stmt)
+
             case _:
                 self.current.statements.append(stmt)
 
@@ -153,7 +142,7 @@ class CFGBuilder:
 
         self.current = after_block
 
-    def _visit_for(self, stmt: ast.For) -> None:
+    def _visit_for(self, stmt: ast.For | ast.AsyncFor) -> None:
         iter_block = self.cfg.create_block()
         body_block = self.cfg.create_block()
         after_block = self.cfg.create_block()
@@ -171,3 +160,104 @@ class CFGBuilder:
             self.current.add_successor(iter_block)
 
         self.current = after_block
+
+    def _visit_with(self, stmt: ast.With | ast.AsyncWith) -> None:
+        # Treat WITH as linear flow (enter -> body -> exit), but preserve
+        # block structure
+        # We record the context manager expression in the current block
+        # Then we enter a new block for the body (to separate it structurally)
+        # Then we enter a new block for 'after' (exit)
+
+        # Why new block? Because 'with' implies a scope/context.
+        # It helps matching.
+
+        body_block = self.cfg.create_block()
+        after_block = self.cfg.create_block()
+
+        # Record the 'items' (context managers)
+        # We wrap them in Expr to treat them as statements for hashing
+        for item in stmt.items:
+            self.current.statements.append(ast.Expr(value=item.context_expr))
+
+        self.current.add_successor(body_block)
+
+        self.current = body_block
+        self._visit_statements(stmt.body)
+        if not self.current.is_terminated:
+            self.current.add_successor(after_block)
+
+        self.current = after_block
+
+    def _visit_try(self, stmt: _TryLike) -> None:
+        try_entry = self.cfg.create_block()
+        self.current.add_successor(try_entry)
+        self.current = try_entry
+
+        handlers_blocks = [self.cfg.create_block() for _ in stmt.handlers]
+        else_block = self.cfg.create_block() if stmt.orelse else None
+        final_block = self.cfg.create_block()
+
+        # Process each statement in try body
+        # Link each to exception handlers
+        for stmt_node in stmt.body:
+            if self.current.is_terminated:
+                break
+
+            # Current statement could raise exception
+            for h_block in handlers_blocks:
+                self.current.add_successor(h_block)
+
+            self._visit(stmt_node)
+
+        # Normal exit from try
+        if not self.current.is_terminated:
+            if else_block:
+                self.current.add_successor(else_block)
+            else:
+                self.current.add_successor(final_block)
+
+        # Process handlers
+        for handler, h_block in zip(stmt.handlers, handlers_blocks, strict=True):
+            self.current = h_block
+            if handler.type:
+                self.current.statements.append(ast.Expr(value=handler.type))
+
+            self._visit_statements(handler.body)
+            if not self.current.is_terminated:
+                self.current.add_successor(final_block)
+
+        # Process else
+        if else_block:
+            self.current = else_block
+            self._visit_statements(stmt.orelse)
+            if not self.current.is_terminated:
+                self.current.add_successor(final_block)
+
+        # Process finally
+        self.current = final_block
+        if stmt.finalbody:
+            self._visit_statements(stmt.finalbody)
+
+    def _visit_match(self, stmt: ast.Match) -> None:
+        self.current.statements.append(ast.Expr(value=stmt.subject))
+
+        subject_block = self.current
+        after_block = self.cfg.create_block()
+
+        for case_ in stmt.cases:
+            case_block = self.cfg.create_block()
+            subject_block.add_successor(case_block)
+
+            self.current = case_block
+
+            # Record pattern structure
+            pattern_repr = ast.dump(case_.pattern, annotate_fields=False)
+            self.current.statements.append(
+                ast.Expr(value=ast.Constant(value=f"PATTERN:{pattern_repr}"))
+            )
+
+            self._visit_statements(case_.body)
+            if not self.current.is_terminated:
+                self.current.add_successor(after_block)
+
+        self.current = after_block

codeclone/cfg_model.py

@@ -0,0 +1,47 @@
+"""
+CodeClone — AST and CFG-based code clone detector for Python
+focused on architectural duplication.
+
+Copyright (c) 2026 Den Rozhnovskiy
+Licensed under the MIT License.
+"""
+
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass, field
+
+
+@dataclass(eq=False, slots=True)
+class Block:
+    id: int
+    statements: list[ast.stmt] = field(default_factory=list)
+    successors: set[Block] = field(default_factory=set)
+    is_terminated: bool = False
+
+    def add_successor(self, block: Block) -> None:
+        self.successors.add(block)
+
+    def __hash__(self) -> int:
+        return hash(self.id)
+
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, Block) and self.id == other.id
+
+
+@dataclass(slots=True)
+class CFG:
+    qualname: str
+    blocks: list[Block] = field(default_factory=list)
+
+    entry: Block = field(init=False)
+    exit: Block = field(init=False)
+
+    def __post_init__(self) -> None:
+        self.entry = self.create_block()
+        self.exit = self.create_block()
+
+    def create_block(self) -> Block:
+        block = Block(id=len(self.blocks))
+        self.blocks.append(block)
+        return block