codeclone 1.2.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,14 +9,19 @@ Licensed under the MIT License.
 from __future__ import annotations
 
 import json
+from collections.abc import Mapping
 from pathlib import Path
+from typing import Any
 
 
 class Baseline:
+    __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.python_version: str | None = None
 
     def load(self) -> None:
         if not self.path.exists():
@@ -26,6 +31,10 @@ class Baseline:
             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
 
@@ -33,10 +42,7 @@ class Baseline:
         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,
             ),
@@ -45,14 +51,34 @@ class Baseline:
 
     @staticmethod
     def from_groups(
-        func_groups: dict, block_groups: dict, path: str | Path = ""
-    ) -> "Baseline":
+        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,47 +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 Any, 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:
+    __slots__ = ("data", "load_warning", "path", "secret")
+    CACHE_VERSION = "1.0"
+
     def __init__(self, path: str | Path):
         self.path = Path(path)
-        self.data: dict[str, Any] = {"files": {}}
+        self.data: CacheData = {"version": self.CACHE_VERSION, "files": {}}
+        self.secret = self._load_secret()
+        self.load_warning: str | None = None
 
-    def load(self) -> None:
-        if self.path.exists():
+    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.data = json.loads(self.path.read_text("utf-8"))
-            except json.JSONDecodeError:
-                # If cache is corrupted, start fresh
-                self.data = {"files": {}}
+                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 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[str, Any]]:
-        return self.data.get("files", {}).get(filepath)
+        return entry
 
     def put_file_entry(
-        self, filepath: str, stat_sig: dict[str, Any], units: list, blocks: list
+        self,
+        filepath: str,
+        stat_sig: FileStat,
+        units: list[Unit],
+        blocks: list[BlockUnit],
     ) -> None:
-        self.data.setdefault("files", {})[filepath] = {
+        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
@@ -110,8 +85,10 @@ class CFGBuilder:
             case ast.AsyncFor():
                 self._visit_for(stmt)  # Structure is identical to For
 
-            case ast.Try() | ast.TryStar():
-                self._visit_try(stmt)
+            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)
@@ -185,7 +162,8 @@ class CFGBuilder:
         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
+        # 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)
@@ -210,126 +188,73 @@ class CFGBuilder:
 
         self.current = after_block
 
-    def _visit_try(self, stmt: ast.Try | ast.TryStar) -> None:
-        # Simplified Try CFG:
-        # Try Body -> [Handlers...] -> Finally/After
-        # Try Body -> Else -> Finally/After
-
-        try_block = self.cfg.create_block()
-        self.current.add_successor(try_block)
-
-        # We don't know WHERE in the try block exception happens, so we assume
-        # any point in try block *could* jump to handlers.
-        # But for structural hashing, we just process the body.
-        # Ideally, we should link the try_block (or its end) to handlers?
-        # A simple approximation:
-        # 1. Process body.
-        # 2. Link entry (or end of body) to handlers?
-        # Let's do: Entry -> BodyBlock.
-        # Entry -> HandlerBlocks (to represent potential jump).
-
-        # Actually, let's keep it linear but branched.
-        # Current -> TryBody
-        # Current -> Handlers (Abstractly representing the jump)
+    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()  # This is finally or after
+        final_block = self.cfg.create_block()
 
-        # Link current to TryBody
-        self.current = try_block
-        self._visit_statements(stmt.body)
+        # 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)
 
-        # If try body finishes successfully:
+        # 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)
 
-        # Handle 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)
-
-        # Handle Handlers
-        # We assume control flow *could* jump from start of Try to any handler
-        # (Technically from inside try, but we model structural containment)
-        # To make fingerprints stable, we just need to ensure handlers are visited
-        # and linked.
-
-        # We link the *original* predecessor (before try) or the try_block start to handlers?
-        # Let's link the `try_block` (as a container concept) to handlers.
-        # But `try_block` was mutated by `_visit_statements`.
-        # Let's use the `try_block` (start of try) to link to handlers.
-        for h_block in handlers_blocks:
-            try_block.add_successor(h_block)
-
-        for handler, h_block in zip(stmt.handlers, handlers_blocks):
+        # Process handlers
+        for handler, h_block in zip(stmt.handlers, handlers_blocks, strict=True):
             self.current = h_block
-            # Record exception type
             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)
 
-        # Finally logic:
-        # If there is a finally block, `final_block` IS the finally block.
-        # We visit it. Then we create a new `after_finally` block?
-        # Or `final_block` is the start of finally.
+        # 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.current = final_block
             self._visit_statements(stmt.finalbody)
-            # And then continue to next code?
-            # Yes, finally flows to next statement.
-            # Unless terminated.
-
-        # If no finally, `final_block` is just the merge point (after).
-        self.current = final_block
 
     def _visit_match(self, stmt: ast.Match) -> None:
-        # Match subject -> Cases -> After
-
         self.current.statements.append(ast.Expr(value=stmt.subject))
 
-        after_block = self.cfg.create_block()
-
-        for case_ in stmt.cases:
-            case_block = self.cfg.create_block()
-            self.current.add_successor(case_block)
-
-            # Save current context to restore for next case branching?
-            # No, 'current' is the match subject block. It branches to ALL cases.
-
-            # Visit Case
-            # We must set self.current to case_block for visiting body
-            # But we lose reference to 'match subject block' to link next case!
-            # So we need a variable `subject_block`.
-            pass
-
-        # Re-implementing loop correctly
         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
-            # We could record the pattern here?
-            # patterns are complex AST nodes. For now, let's skip pattern structure hash
-            # and just hash the body. Or dump pattern as statement?
-            # Pattern is not a statement.
-            # Let's ignore pattern details for V1, or try to normalize it.
-            # If we ignore pattern, then `case []:` and `case {}:` look same.
-            # Ideally: `self.current.statements.append(case_.pattern)` but pattern is not stmt.
-            # We can wrap in Expr? `ast.Expr(value=case_.pattern)`?
-            # Pattern is NOT an Expr subclass in 3.10. It's `ast.pattern`.
-            # So we cannot append it to `statements` list which expects `ast.stmt`.
-            # We will ignore pattern structure for now (it's structural flow we care about).
+
+            # 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:

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