codeclone 1.0.0__py3-none-any.whl

codeclone/baseline.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Set
+
+
+class Baseline:
+    def __init__(self, path: str):
+        self.path = Path(path)
+        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", []))
+
+    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),
+                },
+                indent=2,
+                ensure_ascii=False,
+            ),
+            "utf-8",
+        )
+
+    @staticmethod
+    def from_groups(func_groups: dict, block_groups: dict) -> "Baseline":
+        bl = Baseline("")
+        bl.functions = set(func_groups.keys())
+        bl.blocks = set(block_groups.keys())
+        return bl
+
+    def diff(self, func_groups: dict, block_groups: dict) -> tuple[set, set]:
+        new_funcs = set(func_groups.keys()) - self.functions
+        new_blocks = set(block_groups.keys()) - self.blocks
+        return new_funcs, new_blocks

codeclone/blockhash.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+import ast
+import hashlib
+
+from .normalize import NormalizationConfig, AstNormalizer
+
+def stmt_hash(stmt: ast.stmt, cfg: NormalizationConfig) -> str:
+    normalizer = AstNormalizer(cfg)
+    stmt = ast.fix_missing_locations(normalizer.visit(stmt))
+    dump = ast.dump(stmt, annotate_fields=True, include_attributes=False)
+    return hashlib.sha1(dump.encode("utf-8")).hexdigest()

codeclone/blocks.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass
+
+from .blockhash import stmt_hash
+from .normalize import NormalizationConfig
+
+
+@dataclass(frozen=True)
+class BlockUnit:
+    block_hash: str
+    filepath: str
+    qualname: str
+    start_line: int
+    end_line: int
+    size: int
+
+
+def extract_blocks(
+        func_node: ast.AST,
+        *,
+        filepath: str,
+        qualname: str,
+        cfg: NormalizationConfig,
+        block_size: int,
+        max_blocks: int,
+) -> list[BlockUnit]:
+    body = getattr(func_node, "body", None)
+    if not isinstance(body, list) or len(body) < block_size:
+        return []
+
+    stmt_hashes = [stmt_hash(stmt, cfg) for stmt in body]
+
+    blocks: list[BlockUnit] = []
+    last_start: int | None = None
+    MIN_LINE_DISTANCE = 5  # suppress overlapping windows
+
+    for i in range(len(stmt_hashes) - block_size + 1):
+        start = getattr(body[i], "lineno", None)
+        end = getattr(body[i + block_size - 1], "end_lineno", None)
+        if not start or not end:
+            continue
+
+        if last_start is not None and start - last_start < MIN_LINE_DISTANCE:
+            continue
+
+        bh = "|".join(stmt_hashes[i:i + block_size])
+
+        blocks.append(BlockUnit(
+            block_hash=bh,
+            filepath=filepath,
+            qualname=qualname,
+            start_line=start,
+            end_line=end,
+            size=block_size,
+        ))
+
+        last_start = start
+        if len(blocks) >= max_blocks:
+            break
+
+    return blocks

codeclone/cache.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import asdict
+from pathlib import Path
+from typing import Optional
+
+
+class Cache:
+    def __init__(self, path: str):
+        self.path = Path(path)
+        self.data: dict = {"files": {}}
+
+    def load(self) -> None:
+        if self.path.exists():
+            self.data = json.loads(self.path.read_text("utf-8"))
+
+    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",
+        )
+
+    def get_file_entry(self, filepath: str) -> Optional[dict]:
+        return self.data.get("files", {}).get(filepath)
+
+    def put_file_entry(self, filepath: str, stat_sig: dict, units, blocks) -> None:
+        self.data.setdefault("files", {})[filepath] = {
+            "stat": stat_sig,
+            "units": [asdict(u) for u in units],
+            "blocks": [asdict(b) for b in blocks],
+        }
+
+
+def file_stat_signature(path: str) -> dict:
+    st = os.stat(path)
+    return {
+        "mtime_ns": st.st_mtime_ns,
+        "size": st.st_size,
+    }

codeclone/cli.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from .baseline import Baseline
+from .cache import Cache, file_stat_signature
+from .extractor import extract_units_from_source
+from .normalize import NormalizationConfig
+from .report import build_groups, build_block_groups, to_json, to_text
+from .scanner import iter_py_files, module_name_from_path
+
+
+def main():
+    ap = argparse.ArgumentParser("codeclone")
+    ap.add_argument("root", help="Project root")
+    ap.add_argument("--cache", default="~/.cache/codeclone/")
+    ap.add_argument("--min-loc", type=int, default=15)
+    ap.add_argument("--min-stmt", type=int, default=6)
+    ap.add_argument("--json-out", default="")
+    ap.add_argument("--text-out", default="")
+    ap.add_argument("--fail-if-groups", type=int, default=-1)
+    ap.add_argument("--baseline", default="~/.config/codeclone/baseline.json")
+    ap.add_argument("--update-baseline", action="store_true",
+                    help="Write current clones as baseline")
+    ap.add_argument("--fail-on-new", action="store_true",
+                    help="Fail if new clones appear vs baseline")
+    args = ap.parse_args()
+
+    cfg = NormalizationConfig(
+        ignore_docstrings=True,
+        ignore_type_annotations=True,
+        normalize_attributes=True,
+        normalize_constants=True,
+        normalize_names=True,
+    )
+
+    cache = Cache(args.cache)
+    cache.load()
+
+    all_units: list[dict] = []
+    all_blocks: list[dict] = []
+    changed = 0
+
+    for fp in iter_py_files(args.root):
+        stat = file_stat_signature(fp)
+        cached = cache.get_file_entry(fp)
+
+        if cached and cached.get("stat") == stat:
+            all_units.extend(cached.get("units", []))
+            all_blocks.extend(cached.get("blocks", []))
+            continue
+
+        try:
+            source = Path(fp).read_text("utf-8")
+        except UnicodeDecodeError:
+            continue
+
+        module_name = module_name_from_path(args.root, fp)
+        units, blocks = extract_units_from_source(
+            source=source,
+            filepath=fp,
+            module_name=module_name,
+            cfg=cfg,
+            min_loc=args.min_loc,
+            min_stmt=args.min_stmt,
+        )
+
+        cache.put_file_entry(fp, stat, units, blocks)
+        changed += 1
+
+        all_units.extend([u.__dict__ for u in units])
+        all_blocks.extend([b.__dict__ for b in blocks])
+
+    func_groups = build_groups(all_units)
+    block_groups = build_block_groups(all_blocks)
+
+    baseline = Baseline(args.baseline)
+    baseline.load()
+
+    if args.update_baseline:
+        new_baseline = Baseline.from_groups(func_groups, block_groups)
+        new_baseline.path = Path(args.baseline)
+        new_baseline.save()
+        print(f"Baseline updated: {args.baseline}")
+        return
+
+    new_func, new_block = baseline.diff(func_groups, block_groups)
+
+    if args.json_out:
+        out = Path(args.json_out)
+        out.parent.mkdir(parents=True, exist_ok=True)
+        out.write_text(
+            to_json({
+                "functions": func_groups,
+                "blocks": block_groups,
+            }),
+            "utf-8",
+        )
+
+    if args.text_out:
+        out = Path(args.text_out)
+        out.parent.mkdir(parents=True, exist_ok=True)
+        out.write_text(
+            "FUNCTION CLONES\n"
+            + to_text(func_groups)
+            + "\nBLOCK CLONES\n"
+            + to_text(block_groups),
+            "utf-8",
+        )
+
+    print(f"Scanned root: {args.root}")
+    print(f"Changed files parsed: {changed}")
+    print(f"Function clone groups: {len(func_groups)}")
+    print(f"Block clone groups: {len(block_groups)}")
+
+    if args.fail_on_new:
+        if new_func or new_block:
+            print("\n❌ New code clones detected\n")
+
+            if new_func:
+                print(f"New FUNCTION clone groups: {len(new_func)}")
+                for k in sorted(new_func):
+                    print(f"  - {k}")
+
+            if new_block:
+                print(f"New BLOCK clone groups: {len(new_block)}")
+                for k in sorted(new_block):
+                    print(f"  - {k}")
+
+            raise SystemExit(3)
+
+    print(f"Baseline function clones: {len(baseline.functions)}")
+    print(f"Baseline block clones: {len(baseline.blocks)}")
+    print(f"New function clones: {len(new_func)}")
+    print(f"New block clones: {len(new_block)}")
+
+    cache.save()
+
+    if 0 <= args.fail_if_groups < len(func_groups):
+        raise SystemExit(2)
+
+
+if __name__ == "__main__":
+    main()

codeclone/extractor.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass
+
+from .blocks import extract_blocks, BlockUnit
+from .fingerprint import sha1, bucket_loc
+from .normalize import NormalizationConfig, normalized_ast_dump
+
+
+@dataclass(frozen=True)
+class Unit:
+    qualname: str
+    filepath: str
+    start_line: int
+    end_line: int
+    loc: int
+    stmt_count: int
+    fingerprint: str
+    loc_bucket: str
+
+
+def _stmt_count(node: ast.AST) -> int:
+    body = getattr(node, "body", None)
+    return len(body) if isinstance(body, list) else 0
+
+
+class _QualnameBuilder(ast.NodeVisitor):
+    def __init__(self):
+        self.stack: list[str] = []
+        self.units: list[tuple[str, ast.AST]] = []
+
+    def visit_ClassDef(self, node: ast.ClassDef):
+        self.stack.append(node.name)
+        self.generic_visit(node)
+        self.stack.pop()
+
+    def visit_FunctionDef(self, node: ast.FunctionDef):
+        name = ".".join(self.stack + [node.name]) if self.stack else node.name
+        self.units.append((name, node))
+
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef):
+        name = ".".join(self.stack + [node.name]) if self.stack else node.name
+        self.units.append((name, node))
+
+
+def extract_units_from_source(
+        source: str,
+        filepath: str,
+        module_name: str,
+        cfg: NormalizationConfig,
+        min_loc: int,
+        min_stmt: int,
+) -> tuple[list[Unit], list[BlockUnit]]:
+    try:
+        tree = ast.parse(source)
+    except SyntaxError:
+        return [], []
+
+    qb = _QualnameBuilder()
+    qb.visit(tree)
+
+    units: list[Unit] = []
+    block_units: list[BlockUnit] = []
+
+    for local_name, node in qb.units:
+        start = getattr(node, "lineno", None)
+        end = getattr(node, "end_lineno", None)
+        if not start or not end or end < start:
+            continue
+
+        loc = end - start + 1
+        stmt_count = _stmt_count(node)
+
+        if loc < min_loc or stmt_count < min_stmt:
+            continue
+
+        qualname = f"{module_name}:{local_name}"
+        dump = normalized_ast_dump(node, cfg)
+        fp = sha1(dump)
+
+        # ✅ __init__ INCLUDED as function-level unit
+        units.append(Unit(
+            qualname=qualname,
+            filepath=filepath,
+            start_line=start,
+            end_line=end,
+            loc=loc,
+            stmt_count=stmt_count,
+            fingerprint=fp,
+            loc_bucket=bucket_loc(loc),
+        ))
+
+        if (
+                not local_name.endswith("__init__")
+                and loc >= 40
+                and stmt_count >= 10
+        ):
+            blocks = extract_blocks(
+                node,
+                filepath=filepath,
+                qualname=qualname,
+                cfg=cfg,
+                block_size=4,
+                max_blocks=15,
+            )
+            block_units.extend(blocks)
+
+    return units, block_units

codeclone/fingerprint.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+import hashlib
+
+def sha1(s: str) -> str:
+    return hashlib.sha1(s.encode("utf-8")).hexdigest()
+
+def bucket_loc(loc: int) -> str:
+    # Helps avoid grouping wildly different sizes if desired
+    if loc < 20:
+        return "0-19"
+    if loc < 50:
+        return "20-49"
+    if loc < 100:
+        return "50-99"
+    return "100+"

codeclone/normalize.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class NormalizationConfig:
+    ignore_docstrings: bool = True
+    ignore_type_annotations: bool = True
+    normalize_attributes: bool = True  # obj.foo -> obj._ATTR_
+    normalize_constants: bool = True  # 123/"x"/None -> _CONST_
+    normalize_names: bool = True  # x,y,z -> _VAR_
+
+
+class AstNormalizer(ast.NodeTransformer):
+    def __init__(self, cfg: NormalizationConfig):
+        self.cfg = cfg
+        super().__init__()
+
+    def visit_FunctionDef(self, node: ast.FunctionDef):
+        return self._visit_func(node)
+
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef):
+        return self._visit_func(node)
+
+    def _visit_func(self, node):
+        # Drop docstring (first Expr(Constant(str)))
+        if self.cfg.ignore_docstrings and node.body:
+            first = node.body[0]
+            if isinstance(first, ast.Expr) and isinstance(getattr(first, "value", None), ast.Constant):
+                if isinstance(first.value.value, str):
+                    node.body = node.body[1:]
+
+        if self.cfg.ignore_type_annotations:
+            # Remove annotations in args + returns
+            if hasattr(node, "returns"):
+                node.returns = None
+            args = node.args
+            for a in getattr(args, "posonlyargs", []):
+                a.annotation = None
+            for a in getattr(args, "args", []):
+                a.annotation = None
+            for a in getattr(args, "kwonlyargs", []):
+                a.annotation = None
+            if getattr(args, "vararg", None):
+                args.vararg.annotation = None
+            if getattr(args, "kwarg", None):
+                args.kwarg.annotation = None
+
+        return self.generic_visit(node)
+
+    def visit_arg(self, node: ast.arg):
+        if self.cfg.ignore_type_annotations:
+            node.annotation = None
+        return node
+
+    def visit_Name(self, node: ast.Name):
+        if self.cfg.normalize_names:
+            node.id = "_VAR_"
+        return node
+
+    def visit_Attribute(self, node: ast.Attribute):
+        node = self.generic_visit(node)
+        if self.cfg.normalize_attributes:
+            node.attr = "_ATTR_"
+        return node
+
+    def visit_Constant(self, node: ast.Constant):
+        if self.cfg.normalize_constants:
+            # Preserve booleans? up to you; default: normalize everything
+            node.value = "_CONST_"
+        return node
+
+
+def normalized_ast_dump(func_node: ast.AST, cfg: NormalizationConfig) -> str:
+    """
+    Returns stable string representation of normalized AST.
+    """
+    normalizer = AstNormalizer(cfg)
+    new_node = ast.fix_missing_locations(normalizer.visit(ast.copy_location(func_node, func_node)))
+    # include_attributes=False => more stable; annotate_fields=True => default
+    return ast.dump(new_node, annotate_fields=True, include_attributes=False)

codeclone/report.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+
+def build_groups(units: list[dict[str, Any]]) -> dict[str, list[dict]]:
+    groups: dict[str, list[dict]] = {}
+    for u in units:
+        key = f"{u['fingerprint']}|{u['loc_bucket']}"
+        groups.setdefault(key, []).append(u)
+    return {k: v for k, v in groups.items() if len(v) > 1}
+
+
+def build_block_groups(blocks: list[dict], min_functions: int = 2) -> dict[str, list[dict]]:
+    groups: dict[str, list[dict]] = {}
+    for b in blocks:
+        groups.setdefault(b["block_hash"], []).append(b)
+
+    filtered: dict[str, list[dict]] = {}
+    for h, items in groups.items():
+        functions = {i["qualname"] for i in items}
+        if len(functions) >= min_functions:
+            filtered[h] = items
+
+    return filtered
+
+
+def to_json(groups: dict) -> str:
+    return json.dumps({
+        "group_count": len(groups),
+        "groups": [
+            {"key": k, "count": len(v), "items": v}
+            for k, v in sorted(groups.items(), key=lambda kv: len(kv[1]), reverse=True)
+        ],
+    }, ensure_ascii=False, indent=2)
+
+
+def to_text(groups: dict) -> str:
+    lines: list[str] = []
+    for i, (_, v) in enumerate(
+            sorted(groups.items(), key=lambda kv: len(kv[1]), reverse=True)
+    ):
+        lines.append(f"\n=== Clone group #{i + 1} (count={len(v)}) ===")
+        for item in v:
+            lines.append(
+                f"- {item['qualname']} "
+                f"{item['filepath']}:{item['start_line']}-{item['end_line']} "
+                f"loc={item.get('loc', item.get('size'))}"
+            )
+    return "\n".join(lines).strip() + "\n"

codeclone/scanner.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Iterable
+
+DEFAULT_EXCLUDES = (
+    ".git", ".venv", "venv", "__pycache__", "site-packages",
+    "migrations", "alembic", "dist", "build", ".tox",
+)
+
+def iter_py_files(root: str, excludes: tuple[str, ...] = DEFAULT_EXCLUDES) -> Iterable[str]:
+    rootp = Path(root)
+    for p in rootp.rglob("*.py"):
+        parts = set(p.parts)
+        if any(ex in parts for ex in excludes):
+            continue
+        yield str(p)
+
+def module_name_from_path(root: str, filepath: str) -> str:
+    rootp = Path(root).resolve()
+    fp = Path(filepath).resolve()
+    rel = fp.relative_to(rootp)
+    # strip ".py"
+    stem = rel.with_suffix("")
+    # __init__.py -> package name
+    if stem.name == "__init__":
+        stem = stem.parent
+    return ".".join(stem.parts)

codeclone-1.0.0.dist-info/METADATA

@@ -0,0 +1,211 @@
+Metadata-Version: 2.4
+Name: codeclone
+Version: 1.0.0
+Summary: AST-based code clone detector for Python focused on architectural duplication
+Author-email: Den Rozhnovskiy <pytelemonbot@mail.ru>
+Maintainer-email: Den Rozhnovskiy <pytelemonbot@mail.ru>
+License: MIT
+Project-URL: Homepage, https://github.com/orenlab/codeclone
+Project-URL: Repository, https://github.com/orenlab/codeclone
+Project-URL: Issues, https://github.com/orenlab/codeclone/issues
+Project-URL: Changelog, https://github.com/orenlab/codeclone/releases
+Keywords: python,ast,code-clone,duplication,static-analysis,ci,architecture
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: Testing
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+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: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=9.0.0; extra == "dev"
+Requires-Dist: build>=1.2.0; extra == "dev"
+Requires-Dist: twine>=5.0.0; extra == "dev"
+Dynamic: license-file
+
+# CodeClone
+
+**CodeClone** is an AST-based code clone detector for Python, focused on **architectural duplication**, not simple
+copy-paste.
+
+It is designed to help teams:
+
+- discover structural and logical code duplication,
+- understand architectural hotspots,
+- and prevent *new* duplication from entering the codebase via CI.
+
+Unlike token- or text-based tools, CodeClone works on **normalized Python AST**, which makes it robust against renaming,
+formatting, and minor refactoring.
+
+---
+
+## Why CodeClone?
+
+Most existing tools detect *textual* duplication.
+CodeClone detects **structural and block-level duplication** that usually indicates missing abstractions or
+architectural drift.
+
+Typical use cases:
+
+- duplicated service logic across layers (API ↔ application),
+- repeated validation or guard blocks,
+- copy-pasted request/handler flows,
+- duplicated orchestration logic in routers, handlers, or services.
+
+---
+
+## Features
+
+### Function-level clone detection (Type-2)
+
+- Detects functions and methods with identical structure.
+- Robust to:
+    - variable renaming,
+    - constant changes,
+    - formatting differences.
+- Ideal for spotting architectural duplication between layers.
+
+### Block-level clone detection (Type-3-lite)
+
+- Detects repeated **statement blocks** inside larger functions.
+- Targets:
+    - validation blocks,
+    - guard clauses,
+    - repeated orchestration logic.
+- Carefully filtered to avoid noise:
+    - no overlapping windows,
+    - no clones inside the same function,
+    - no `__init__` noise.
+
+### Low-noise by design
+
+- AST normalization instead of token matching.
+- Size and statement-count thresholds.
+- Conservative defaults tuned for real-world Python projects.
+
+### CI-friendly baseline mode
+
+- Establish a baseline of existing clones.
+- Fail CI **only when new clones are introduced**.
+- Safe for legacy codebases.
+
+---
+
+## Installation
+
+```bash
+pip install codeclone
+```
+
+Python 3.10+ is required.
+
+⸻
+
+Quick Start
+
+Run on a project:
+
+```bash
+codeclone .
+```
+
+This will:
+
+* scan Python files,
+* detect function-level and block-level clones,
+* print a summary to stdout.
+
+Generate reports:
+
+```bash
+codeclone . \
+  --json-out .cache/codeclone/report.json \
+  --text-out .cache/codeclone/report.txt
+```
+
+⸻
+
+Baseline Workflow (Recommended)
+
+1. Create a baseline
+
+Run once on your current codebase:
+
+```bash
+codeclone . --update-baseline
+```
+
+This creates a file:
+
+```bash
+.codeclone-baseline.json
+```
+
+Commit this file to the repository.
+
+⸻
+
+2. Use in CI
+
+In CI, run:
+
+```bash
+codeclone . --fail-on-new
+```
+
+Behavior:
+
+* ✅ existing clones are allowed,
+* ❌ build fails if new function or block clones appear,
+* ✅ refactoring that removes duplication is always allowed.
+
+This enables gradual improvement without breaking existing development flow.
+
+⸻
+
+What CodeClone Is (and Is Not)
+
+CodeClone is
+
+* an architectural analysis tool,
+* a duplication radar,
+* a CI guard against copy-paste.
+
+CodeClone is not
+
+* a linter,
+* a formatter,
+* a replacement for SonarQube or static analyzers,
+* a semantic equivalence prover.
+
+It intentionally focuses on high-signal duplication.
+
+⸻
+
+How It Works (High Level)
+
+* Parses Python source into AST.
+* Normalizes:
+    - variable names,
+    - constants,
+    - attributes,
+    - docstrings and annotations.
+* Computes stable structural fingerprints.
+* Detects:
+    - identical function structures,
+    - repeated statement blocks across functions.
+* Applies filters to suppress noise.
+
+⸻
+
+License
+
+MIT License

codeclone-1.0.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+codeclone/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+codeclone/baseline.py,sha256=1848Ugh4l3czOUIgXN68oPx_tu2nzbnnZQUixD1OXXA,1367
+codeclone/blockhash.py,sha256=QewX6jSCc7Q2tDsBXicFGzaMzKPb2S6unMEZEvwuwDs,414
+codeclone/blocks.py,sha256=6nXELQsH2OKl7ScNyLQiR7rMY2jfnsnGTt5_yXbwh3Y,1533
+codeclone/cache.py,sha256=kiqfj5V3evW3hyhKMVqW7EFUiN9AO4mntFPUzfXAjsA,1156
+codeclone/cli.py,sha256=uggGIVDw2QLQKKh5BsZYb2XGpe0ysEsQKx-7JDcepXA,4526
+codeclone/extractor.py,sha256=ubMfYfM87F1apEmzBnnv9W4daY7Gv2nQHthiNoeTTno,2884
+codeclone/fingerprint.py,sha256=pSucv648MGe6LwNczxJBbQjnAOcpHgkXSokaHwGr5zw,364
+codeclone/normalize.py,sha256=hG__ZqJCtUMVIv7c_a9PHfzSVGDbrAIOH5JYXnLfuOk,2930
+codeclone/report.py,sha256=Ptgne99-nsyvAGyJL3SsPNH9fQLorV2mVf--a0KXfxE,1639
+codeclone/scanner.py,sha256=_xomEXvx1mLhMVRiMXW-gkBUV_9Z3GixFV5nK0Pqeq4,831
+codeclone-1.0.0.dist-info/licenses/LICENSE,sha256=ndXAbunvN-jCQjgCaoBOF5AN4FcRlAa0R7hK1lWDuBU,1073
+codeclone-1.0.0.dist-info/METADATA,sha256=F9-0TneuHJuI2USqeIgW0Ayrue4KVTL-5Um69vaN3-I,4993
+codeclone-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+codeclone-1.0.0.dist-info/entry_points.txt,sha256=_MI9DVTLOmv3OlxpyogdOmMAduiLVIdHeOlZ_KBsrIY,49
+codeclone-1.0.0.dist-info/top_level.txt,sha256=4tQa_d-4Zle-qV9KmNDkWq0WHYgZsW9vdaeF30rNntg,10
+codeclone-1.0.0.dist-info/RECORD,,

codeclone-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

codeclone-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+codeclone = codeclone.cli:main

codeclone-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Denis Rozhnovskiy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

codeclone-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+codeclone