codeclone 1.1.0__tar.gz → 1.2.0__tar.gz

{codeclone-1.1.0 → codeclone-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeclone
-Version: 1.1.0
+Version: 1.2.0
 Summary: AST and CFG-based code clone detector for Python focused on architectural duplication
 Author-email: Den Rozhnovskiy <pytelemonbot@mail.ru>
 Maintainer-email: Den Rozhnovskiy <pytelemonbot@mail.ru>
@@ -23,11 +23,13 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pygments>=2.19.2
+Requires-Dist: rich>=14.3.2
 Provides-Extra: dev
 Requires-Dist: pytest>=9.0.0; extra == "dev"
 Requires-Dist: build>=1.2.0; extra == "dev"
@@ -102,7 +104,12 @@ Typical use cases:
 
 - Each function is converted into a **Control Flow Graph**.
 - CFG nodes contain normalized AST statements.
-- CFG edges represent structural control flow (`if`, `for`, `while`).
+- CFG edges represent structural control flow:
+  - `if` / `else`
+  - `for` / `async for` / `while`
+  - `try` / `except` / `finally`
+  - `with` / `async with`
+  - `match` / `case` (Python 3.10+)
 - Current CFG semantics (v1):
   - `break` and `continue` are treated as statements (no jump targets),
   - after-blocks are explicit and always present,
@@ -154,14 +161,14 @@ Generate reports:
 
 ```bash
 codeclone . \
-  --json-out .cache/codeclone/report.json \
-  --text-out .cache/codeclone/report.txt
+  --json .cache/codeclone/report.json \
+  --text .cache/codeclone/report.txt
 ```
 
 Generate an HTML report:
 
 ```bash
-codeclone . --html-out .cache/codeclone/report.html
+codeclone . --html .cache/codeclone/report.html
 ```
 
 ---
@@ -235,6 +242,9 @@ repos:
 5. Detect function-level and block-level clones.
 6. Apply conservative filters to suppress noise.
 
+See the architectural overview:
+- [docs/architecture.md](docs/architecture.md)
+
 ---
 
 ## Control Flow Graph (CFG)

{codeclone-1.1.0 → codeclone-1.2.0}/README.md

@@ -65,7 +65,12 @@ Typical use cases:
 
 - Each function is converted into a **Control Flow Graph**.
 - CFG nodes contain normalized AST statements.
-- CFG edges represent structural control flow (`if`, `for`, `while`).
+- CFG edges represent structural control flow:
+  - `if` / `else`
+  - `for` / `async for` / `while`
+  - `try` / `except` / `finally`
+  - `with` / `async with`
+  - `match` / `case` (Python 3.10+)
 - Current CFG semantics (v1):
   - `break` and `continue` are treated as statements (no jump targets),
   - after-blocks are explicit and always present,
@@ -117,14 +122,14 @@ Generate reports:
 
 ```bash
 codeclone . \
-  --json-out .cache/codeclone/report.json \
-  --text-out .cache/codeclone/report.txt
+  --json .cache/codeclone/report.json \
+  --text .cache/codeclone/report.txt
 ```
 
 Generate an HTML report:
 
 ```bash
-codeclone . --html-out .cache/codeclone/report.html
+codeclone . --html .cache/codeclone/report.html
 ```
 
 ---
@@ -198,6 +203,9 @@ repos:
 5. Detect function-level and block-level clones.
 6. Apply conservative filters to suppress noise.
 
+See the architectural overview:
+- [docs/architecture.md](docs/architecture.md)
+
 ---
 
 ## Control Flow Graph (CFG)

{codeclone-1.1.0 → codeclone-1.2.0}/codeclone/baseline.py

@@ -10,22 +10,24 @@ from __future__ import annotations
 
 import json
 from pathlib import Path
-from typing import Set
 
 
 class Baseline:
-    def __init__(self, path: str):
+    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()
 
     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", []))
+        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)
@@ -42,8 +44,10 @@ class Baseline:
         )
 
     @staticmethod
-    def from_groups(func_groups: dict, block_groups: dict) -> "Baseline":
-        bl = Baseline("")
+    def from_groups(
+        func_groups: dict, block_groups: dict, path: str | Path = ""
+    ) -> "Baseline":
+        bl = Baseline(path)
         bl.functions = set(func_groups.keys())
         bl.blocks = set(block_groups.keys())
         return bl

{codeclone-1.1.0 → codeclone-1.2.0}/codeclone/cache.py

@@ -12,17 +12,21 @@ import json
 import os
 from dataclasses import asdict
 from pathlib import Path
-from typing import Optional
+from typing import Any, Optional
 
 
 class Cache:
-    def __init__(self, path: str):
+    def __init__(self, path: str | Path):
         self.path = Path(path)
-        self.data: dict = {"files": {}}
+        self.data: dict[str, Any] = {"files": {}}
 
     def load(self) -> None:
         if self.path.exists():
-            self.data = json.loads(self.path.read_text("utf-8"))
+            try:
+                self.data = json.loads(self.path.read_text("utf-8"))
+            except json.JSONDecodeError:
+                # If cache is corrupted, start fresh
+                self.data = {"files": {}}
 
     def save(self) -> None:
         self.path.parent.mkdir(parents=True, exist_ok=True)
@@ -31,10 +35,12 @@ class Cache:
             "utf-8",
         )
 
-    def get_file_entry(self, filepath: str) -> Optional[dict]:
+    def get_file_entry(self, filepath: str) -> Optional[dict[str, Any]]:
         return self.data.get("files", {}).get(filepath)
 
-    def put_file_entry(self, filepath: str, stat_sig: dict, units, blocks) -> None:
+    def put_file_entry(
+        self, filepath: str, stat_sig: dict[str, Any], units: list, blocks: list
+    ) -> None:
         self.data.setdefault("files", {})[filepath] = {
             "stat": stat_sig,
             "units": [asdict(u) for u in units],

codeclone-1.2.0/codeclone/cfg.py

@@ -0,0 +1,338 @@
+"""
+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
+from typing import Iterable
+
+
+# =========================
+# 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)
+
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, Block) and self.id == other.id
+
+
+@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
+
+
+# =========================
+# CFG Builder
+# =========================
+
+
+class CFGBuilder:
+    def __init__(self) -> None:
+        self.cfg: CFG
+        self.current: Block
+
+    def build(
+        self,
+        qualname: str,
+        node: ast.FunctionDef | ast.AsyncFunctionDef,
+    ) -> CFG:
+        self.cfg = CFG(qualname)
+        self.current = self.cfg.entry
+
+        self._visit_statements(node.body)
+
+        if not self.current.is_terminated:
+            self.current.add_successor(self.cfg.exit)
+
+        return self.cfg
+
+    # ---------- Internals ----------
+
+    def _visit_statements(self, stmts: Iterable[ast.stmt]) -> None:
+        for stmt in stmts:
+            if self.current.is_terminated:
+                break
+            self._visit(stmt)
+
+    def _visit(self, stmt: ast.stmt) -> None:
+        match stmt:
+            case ast.Return():
+                self.current.statements.append(stmt)
+                self.current.is_terminated = True
+                self.current.add_successor(self.cfg.exit)
+
+            case ast.Raise():
+                self.current.statements.append(stmt)
+                self.current.is_terminated = True
+                self.current.add_successor(self.cfg.exit)
+
+            case ast.If():
+                self._visit_if(stmt)
+
+            case ast.While():
+                self._visit_while(stmt)
+
+            case ast.For():
+                self._visit_for(stmt)
+
+            case ast.AsyncFor():
+                self._visit_for(stmt)  # Structure is identical to For
+
+            case ast.Try() | ast.TryStar():
+                self._visit_try(stmt)
+
+            case ast.With() | ast.AsyncWith():
+                self._visit_with(stmt)
+
+            case ast.Match():
+                self._visit_match(stmt)
+
+            case _:
+                self.current.statements.append(stmt)
+
+    # ---------- Control Flow ----------
+
+    def _visit_if(self, stmt: ast.If) -> None:
+        self.current.statements.append(ast.Expr(value=stmt.test))
+
+        then_block = self.cfg.create_block()
+        else_block = self.cfg.create_block()
+        after_block = self.cfg.create_block()
+
+        self.current.add_successor(then_block)
+        self.current.add_successor(else_block)
+
+        self.current = then_block
+        self._visit_statements(stmt.body)
+        if not self.current.is_terminated:
+            self.current.add_successor(after_block)
+
+        self.current = else_block
+        self._visit_statements(stmt.orelse)
+        if not self.current.is_terminated:
+            self.current.add_successor(after_block)
+
+        self.current = after_block
+
+    def _visit_while(self, stmt: ast.While) -> None:
+        cond_block = self.cfg.create_block()
+        body_block = self.cfg.create_block()
+        after_block = self.cfg.create_block()
+
+        self.current.add_successor(cond_block)
+
+        self.current = cond_block
+        self.current.statements.append(ast.Expr(value=stmt.test))
+        self.current.add_successor(body_block)
+        self.current.add_successor(after_block)
+
+        self.current = body_block
+        self._visit_statements(stmt.body)
+        if not self.current.is_terminated:
+            self.current.add_successor(cond_block)
+
+        self.current = after_block
+
+    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()
+
+        self.current.add_successor(iter_block)
+
+        self.current = iter_block
+        self.current.statements.append(ast.Expr(value=stmt.iter))
+        self.current.add_successor(body_block)
+        self.current.add_successor(after_block)
+
+        self.current = body_block
+        self._visit_statements(stmt.body)
+        if not self.current.is_terminated:
+            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: 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)
+
+        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
+
+        # Link current to TryBody
+        self.current = try_block
+        self._visit_statements(stmt.body)
+
+        # If try body finishes successfully:
+        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):
+            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.
+
+        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
+
+        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).
+
+            self._visit_statements(case_.body)
+            if not self.current.is_terminated:
+                self.current.add_successor(after_block)
+
+        self.current = after_block