'
)
out.append(
- f'
'
- f'
'
- f'
'
+ '
'
+ '
'
+ f'
'
f'
Group #{idx}
'
f'
{len(items)} items'
- f"
"
- f'
'
+ "
"
+ '
'
f'{_escape(gkey)}'
- f"
"
- f"
"
+ "
"
+ "
"
)
out.append(f'
')
@@ -904,9 +455,9 @@ def render_section(
out.append("")
return "\n".join(out)
- # ============================
+ # ============================
# HTML Rendering
- # ============================
+ # ============================
empty_state_html = ""
if not has_any:
@@ -915,13 +466,17 @@ def render_section(
{ICON_CHECK}
No code clones detected
-
No structural or block-level duplication was found above configured thresholds.
+
+ No structural or block-level duplication was found above configured thresholds.
+
This usually indicates healthy abstraction boundaries.
"""
- func_section = render_section("functions", "Function clones", func_sorted, "pill-func")
+ func_section = render_section(
+ "functions", "Function clones", func_sorted, "pill-func"
+ )
block_section = render_section("blocks", "Block clones", block_sorted, "pill-block")
return REPORT_TEMPLATE.substitute(
@@ -933,4 +488,5 @@ def render_section(
func_section=func_section,
block_section=block_section,
icon_theme=ICON_THEME,
+ font_css_url=FONT_CSS_URL,
)
diff --git a/codeclone/normalize.py b/codeclone/normalize.py
index 81c4452..d78f0e0 100644
--- a/codeclone/normalize.py
+++ b/codeclone/normalize.py
@@ -15,7 +15,7 @@
from dataclasses import dataclass
-@dataclass(frozen=True)
+@dataclass(frozen=True, slots=True)
class NormalizationConfig:
ignore_docstrings: bool = True
ignore_type_annotations: bool = True
@@ -25,17 +25,19 @@ class NormalizationConfig:
class AstNormalizer(ast.NodeTransformer):
+ __slots__ = ("cfg",)
+
def __init__(self, cfg: NormalizationConfig):
super().__init__()
self.cfg = cfg
- def visit_FunctionDef(self, node: ast.FunctionDef):
+ def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.AST:
return self._visit_func(node)
- def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef):
+ def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> ast.AST:
return self._visit_func(node)
- def _visit_func(self, node: ast.FunctionDef | ast.AsyncFunctionDef):
+ def _visit_func(self, node: ast.FunctionDef | ast.AsyncFunctionDef) -> ast.AST:
# Drop docstring
if self.cfg.ignore_docstrings and node.body:
first = node.body[0]
@@ -63,12 +65,12 @@ def _visit_func(self, node: ast.FunctionDef | ast.AsyncFunctionDef):
return self.generic_visit(node)
- def visit_arg(self, node: ast.arg):
+ def visit_arg(self, node: ast.arg) -> ast.arg:
if self.cfg.ignore_type_annotations:
node.annotation = None
return node
- def visit_Name(self, node: ast.Name):
+ def visit_Name(self, node: ast.Name) -> ast.Name:
if self.cfg.normalize_names:
node.id = "_VAR_"
return node
@@ -80,7 +82,7 @@ def visit_Attribute(self, node: ast.Attribute) -> ast.Attribute:
new_node.attr = "_ATTR_"
return new_node
- def visit_Constant(self, node: ast.Constant):
+ def visit_Constant(self, node: ast.Constant) -> ast.Constant:
if self.cfg.normalize_constants:
node.value = "_CONST_"
return node
@@ -88,7 +90,8 @@ def visit_Constant(self, node: ast.Constant):
def visit_AugAssign(self, node: ast.AugAssign) -> AST:
# Normalize x += 1 to x = x + 1
# This allows detecting clones where one uses += and another uses = +
- # We transform AugAssign(target, op, value) to Assign([target], BinOp(target, op, value))
+ # We transform AugAssign(target, op, value) to Assign([target],
+ # BinOp(target, op, value))
# Deepcopy target to avoid reuse issues in the AST
target_load = copy.deepcopy(node.target)
@@ -108,23 +111,27 @@ def visit_AugAssign(self, node: ast.AugAssign) -> AST:
def normalized_ast_dump(func_node: ast.AST, cfg: NormalizationConfig) -> str:
+ """
+ Dump the normalized AST.
+ WARNING: This modifies the AST in-place for performance.
+ """
normalizer = AstNormalizer(cfg)
- # Deepcopy to prevent side effects on the original AST
- node_copy = copy.deepcopy(func_node)
- new_node = ast.fix_missing_locations(normalizer.visit(node_copy))
+ new_node = ast.fix_missing_locations(normalizer.visit(func_node))
return ast.dump(new_node, annotate_fields=True, include_attributes=False)
def normalized_ast_dump_from_list(
nodes: Sequence[ast.AST], cfg: NormalizationConfig
) -> str:
+ """
+ Dump a list of AST nodes after normalization.
+ WARNING: This modifies the AST nodes in-place for performance.
+ """
normalizer = AstNormalizer(cfg)
dumps: list[str] = []
for node in nodes:
- # Deepcopy to prevent side effects
- node_copy = copy.deepcopy(node)
- new_node = ast.fix_missing_locations(normalizer.visit(node_copy))
+ new_node = ast.fix_missing_locations(normalizer.visit(node))
dumps.append(ast.dump(new_node, annotate_fields=True, include_attributes=False))
return ";".join(dumps)
diff --git a/codeclone/py.typed b/codeclone/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/codeclone/report.py b/codeclone/report.py
index facaeae..04a83bd 100644
--- a/codeclone/report.py
+++ b/codeclone/report.py
@@ -11,23 +11,24 @@
import json
from typing import Any
+GroupItem = dict[str, Any]
+GroupMap = dict[str, list[GroupItem]]
-def build_groups(units: list[dict[str, Any]]) -> dict[str, list[dict[str, Any]]]:
- groups: dict[str, list[dict[str, Any]]] = {}
+
+def build_groups(units: list[GroupItem]) -> GroupMap:
+ groups: GroupMap = {}
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[str, Any]], min_functions: int = 2
-) -> dict[str, list[dict[str, Any]]]:
- groups: dict[str, list[dict[str, Any]]] = {}
+def build_block_groups(blocks: list[GroupItem], min_functions: int = 2) -> GroupMap:
+ groups: GroupMap = {}
for b in blocks:
groups.setdefault(b["block_hash"], []).append(b)
- filtered: dict[str, list[dict[str, Any]]] = {}
+ filtered: GroupMap = {}
for h, items in groups.items():
functions = {i["qualname"] for i in items}
if len(functions) >= min_functions:
@@ -36,7 +37,7 @@ def build_block_groups(
return filtered
-def to_json(groups: dict) -> str:
+def to_json(groups: GroupMap) -> str:
return json.dumps(
{
"group_count": len(groups),
@@ -52,16 +53,26 @@ def to_json(groups: dict) -> str:
)
-def to_text(groups: dict) -> str:
+def to_json_report(func_groups: GroupMap, block_groups: GroupMap) -> str:
+ return json.dumps(
+ {"functions": func_groups, "blocks": block_groups},
+ ensure_ascii=False,
+ indent=2,
+ )
+
+
+def to_text(groups: GroupMap) -> 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(
+ lines.extend(
+ [
f"- {item['qualname']} "
f"{item['filepath']}:{item['start_line']}-{item['end_line']} "
f"loc={item.get('loc', item.get('size'))}"
- )
+ for item in v
+ ]
+ )
return "\n".join(lines).strip() + "\n"
diff --git a/codeclone/scanner.py b/codeclone/scanner.py
index bd11655..db34202 100644
--- a/codeclone/scanner.py
+++ b/codeclone/scanner.py
@@ -8,8 +8,11 @@
from __future__ import annotations
+import tempfile
+from collections.abc import Iterable
from pathlib import Path
-from typing import Iterable
+
+from .errors import ValidationError
DEFAULT_EXCLUDES = (
".git",
@@ -24,15 +27,75 @@
".tox",
)
+SENSITIVE_DIRS = {
+ "/etc",
+ "/sys",
+ "/proc",
+ "/dev",
+ "/root",
+ "/boot",
+ "/var",
+ "/private/var",
+ "/usr/bin",
+ "/usr/sbin",
+ "/private/etc",
+}
+
+
+def _get_tempdir() -> Path:
+ return Path(tempfile.gettempdir()).resolve()
+
def iter_py_files(
- root: str, excludes: tuple[str, ...] = DEFAULT_EXCLUDES
+ root: str,
+ excludes: tuple[str, ...] = DEFAULT_EXCLUDES,
+ *,
+ max_files: int = 100_000,
) -> Iterable[str]:
- rootp = Path(root)
+ try:
+ rootp = Path(root).resolve(strict=True)
+ except (OSError, RuntimeError) as e:
+ raise ValidationError(f"Invalid root path '{root}': {e}") from e
+
+ if not rootp.is_dir():
+ raise ValidationError(f"Root must be a directory: {root}")
+
+ root_str = str(rootp)
+ temp_root = _get_tempdir()
+ in_temp = False
+ try:
+ rootp.relative_to(temp_root)
+ in_temp = True
+ except ValueError:
+ in_temp = False
+
+ if not in_temp:
+ if root_str in SENSITIVE_DIRS:
+ raise ValidationError(f"Cannot scan sensitive directory: {root}")
+
+ for sensitive in SENSITIVE_DIRS:
+ if root_str.startswith(sensitive + "/"):
+ raise ValidationError(f"Cannot scan under sensitive directory: {root}")
+
+ file_count = 0
for p in rootp.rglob("*.py"):
+ # Verify path is actually under root (prevent symlink attacks)
+ try:
+ p.resolve().relative_to(rootp)
+ except ValueError:
+ # Skipping file outside root (possible symlink traversal)
+ continue
+
parts = set(p.parts)
if any(ex in parts for ex in excludes):
continue
+
+ file_count += 1
+ if file_count > max_files:
+ raise ValidationError(
+ f"File count exceeds limit of {max_files}. "
+ "Use more specific root or increase limit."
+ )
yield str(p)
diff --git a/codeclone/templates.py b/codeclone/templates.py
new file mode 100644
index 0000000..d8870e0
--- /dev/null
+++ b/codeclone/templates.py
@@ -0,0 +1,1262 @@
+"""
+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 string import Template
+
+FONT_CSS_URL = (
+ "https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700"
+ "&family=JetBrains+Mono:wght@400;500;600&display=swap"
+)
+
+REPORT_TEMPLATE = Template(r"""
+
+
+
+
+
+
${title}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
${title}
+
v${version}
+
+
+
+
+
+
+
+
+
+
+${empty_state_html}
+
+${func_section}
+${block_section}
+
+
+
+
+
+
+
+""")
diff --git a/docs/architecture.md b/docs/architecture.md
index 5dfdbdf..c87d4a7 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -101,6 +101,16 @@ Detected clone groups can be:
Baseline comparison allows CI to fail **only on new clones**,
enabling gradual architectural improvement.
+## Python Version Consistency for Baseline Checks
+
+Due to inherent differences in Python’s AST between interpreter versions, baseline
+generation and verification must be performed using the same Python version.
+
+This ensures deterministic and reproducible clone detection results.
+
+CI checks therefore pin baseline verification to a single Python version, while the
+test matrix continues to validate compatibility across Python 3.10–3.14.
+
---
## Design Principles
diff --git a/docs/cfg.md b/docs/cfg.md
index e4adea5..1106771 100644
--- a/docs/cfg.md
+++ b/docs/cfg.md
@@ -189,6 +189,16 @@ CFG v1 guarantees:
This is critical for CI usage and baseline comparison.
+## Python Version Consistency for Baseline Checks
+
+Due to inherent differences in Python’s AST between interpreter versions, baseline
+generation and verification must be performed using the same Python version.
+
+This ensures deterministic and reproducible clone detection results.
+
+CI checks therefore pin baseline verification to a single Python version, while the
+test matrix continues to validate compatibility across Python 3.10–3.14.
+
---
## Why This Is Acceptable (and Intended)
diff --git a/pyproject.toml b/pyproject.toml
index f2ee6c0..4385fe8 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,10 +4,11 @@ build-backend = "setuptools.build_meta"
[project]
name = "codeclone"
-version = "1.2.0"
+version = "1.2.1"
description = "AST and CFG-based code clone detector for Python focused on architectural duplication"
readme = { file = "README.md", content-type = "text/markdown" }
license = { text = "MIT" }
+
authors = [
{ name = "Den Rozhnovskiy", email = "pytelemonbot@mail.ru" }
]
@@ -16,6 +17,7 @@ maintainers = [
]
requires-python = ">=3.10"
+
dependencies = [
"pygments>=2.19.2",
"rich>=14.3.2",
@@ -24,18 +26,20 @@ dependencies = [
keywords = [
"python",
"ast",
+ "cfg",
"code-clone",
"duplication",
"static-analysis",
- "ci",
"architecture",
+ "control-flow",
+ "ci",
]
classifiers = [
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Developers",
+ "Topic :: Software Development :: Static Analysis",
"Topic :: Software Development :: Quality Assurance",
- "Topic :: Software Development :: Code Generators",
"Topic :: Software Development :: Testing",
"Typing :: Typed",
"License :: OSI Approved :: MIT License",
@@ -58,9 +62,11 @@ Documentation = "https://github.com/orenlab/codeclone/tree/main/docs"
[project.optional-dependencies]
dev = [
"pytest>=9.0.0",
+ "pytest-cov>=6.1.0",
"build>=1.2.0",
"twine>=5.0.0",
- "mypy>=1.19.1"
+ "mypy>=1.19.1",
+ "ruff>=0.12.0",
]
[project.scripts]
@@ -68,6 +74,7 @@ codeclone = "codeclone.cli:main"
[tool.setuptools]
packages = ["codeclone"]
+license-files = ["LICENSE"]
[tool.setuptools.package-data]
codeclone = ["py.typed"]
@@ -75,3 +82,29 @@ codeclone = ["py.typed"]
[tool.pytest.ini_options]
testpaths = ["tests"]
addopts = "-ra"
+
+[tool.coverage.run]
+branch = true
+source = ["codeclone"]
+
+[tool.coverage.report]
+show_missing = true
+fail_under = 98
+
+[tool.mypy]
+python_version = "3.10"
+strict = true
+warn_unused_configs = true
+files = ["codeclone", "tests"]
+
+[tool.ruff]
+line-length = 88
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "B", "UP", "SIM", "C4", "PIE", "PERF", "RUF"]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+line-ending = "auto"
diff --git a/tests/test_baseline.py b/tests/test_baseline.py
index 534d082..6247183 100644
--- a/tests/test_baseline.py
+++ b/tests/test_baseline.py
@@ -1,16 +1,18 @@
-from pathlib import Path
import json
+from pathlib import Path
+
import pytest
+
from codeclone.baseline import Baseline
-def test_baseline_diff():
+def test_baseline_diff() -> None:
baseline = Baseline("dummy")
baseline.functions = {"f1"}
baseline.blocks = {"b1"}
- func_groups = {"f1": [], "f2": []}
- block_groups = {"b1": [], "b2": []}
+ func_groups: dict[str, object] = {"f1": [], "f2": []}
+ block_groups: dict[str, object] = {"b1": [], "b2": []}
new_func, new_block = baseline.diff(func_groups, block_groups)
@@ -18,7 +20,7 @@ def test_baseline_diff():
assert new_block == {"b2"}
-def test_baseline_io(tmp_path):
+def test_baseline_io(tmp_path: Path) -> None:
f = tmp_path / "baseline.json"
bl = Baseline(f)
bl.functions = {"f1", "f2"}
@@ -29,6 +31,7 @@ def test_baseline_io(tmp_path):
content = json.loads(f.read_text("utf-8"))
assert content["functions"] == ["f1", "f2"]
assert content["blocks"] == ["b1"]
+ assert "python_version" not in content
bl2 = Baseline(f)
bl2.load()
@@ -36,7 +39,7 @@ def test_baseline_io(tmp_path):
assert bl2.blocks == {"b1"}
-def test_baseline_load_missing(tmp_path):
+def test_baseline_load_missing(tmp_path: Path) -> None:
f = tmp_path / "non_existent.json"
bl = Baseline(f)
bl.load()
@@ -44,7 +47,7 @@ def test_baseline_load_missing(tmp_path):
assert bl.blocks == set()
-def test_baseline_load_corrupted(tmp_path):
+def test_baseline_load_corrupted(tmp_path: Path) -> None:
f = tmp_path / "corrupt.json"
f.write_text("{invalid json", "utf-8")
bl = Baseline(f)
@@ -52,11 +55,27 @@ def test_baseline_load_corrupted(tmp_path):
bl.load()
-def test_baseline_from_groups():
- func_groups = {"f1": [], "f2": []}
- block_groups = {"b1": []}
+def test_baseline_from_groups() -> None:
+ func_groups: dict[str, object] = {"f1": [], "f2": []}
+ block_groups: dict[str, object] = {"b1": []}
bl = Baseline.from_groups(func_groups, block_groups, path="custom.json")
assert bl.functions == {"f1", "f2"}
assert bl.blocks == {"b1"}
assert bl.path == Path("custom.json")
+
+
+def test_baseline_python_version_roundtrip(tmp_path: Path) -> None:
+ f = tmp_path / "baseline.json"
+ bl = Baseline(f)
+ bl.functions = {"f1"}
+ bl.blocks = {"b1"}
+ bl.python_version = "3.13"
+ bl.save()
+
+ content = json.loads(f.read_text("utf-8"))
+ assert content["python_version"] == "3.13"
+
+ bl2 = Baseline(f)
+ bl2.load()
+ assert bl2.python_version == "3.13"
diff --git a/tests/test_blockhash.py b/tests/test_blockhash.py
new file mode 100644
index 0000000..346ae9e
--- /dev/null
+++ b/tests/test_blockhash.py
@@ -0,0 +1,11 @@
+import ast
+
+from codeclone.blockhash import stmt_hash
+from codeclone.normalize import NormalizationConfig
+
+
+def test_stmt_hash_normalizes_names() -> None:
+ cfg = NormalizationConfig()
+ s1 = ast.parse("a = b + 1").body[0]
+ s2 = ast.parse("x = y + 2").body[0]
+ assert stmt_hash(s1, cfg) == stmt_hash(s2, cfg)
diff --git a/tests/test_blocks.py b/tests/test_blocks.py
index 375d3e6..d551666 100644
--- a/tests/test_blocks.py
+++ b/tests/test_blocks.py
@@ -4,7 +4,7 @@
from codeclone.normalize import NormalizationConfig
-def test_extracts_non_overlapping_blocks():
+def test_extracts_non_overlapping_blocks() -> None:
src = """
def f():
a = 1
@@ -30,3 +30,78 @@ def f():
assert len(blocks) <= 2
for b in blocks:
assert b.size == 4
+
+
+def test_extract_blocks_empty_or_short() -> None:
+ short = ast.parse(
+ """
+def f():
+ a = 1
+"""
+ ).body[0]
+ blocks = extract_blocks(
+ short,
+ filepath="x.py",
+ qualname="mod:f",
+ cfg=NormalizationConfig(),
+ block_size=4,
+ max_blocks=10,
+ )
+ assert blocks == []
+
+ assign = ast.parse("x = 1").body[0]
+ blocks2 = extract_blocks(
+ assign,
+ filepath="x.py",
+ qualname="mod:assign",
+ cfg=NormalizationConfig(),
+ block_size=1,
+ max_blocks=10,
+ )
+ assert blocks2 == []
+
+
+def test_extract_blocks_missing_lineno_skips() -> None:
+ func = ast.parse(
+ """
+def f():
+ a = 1
+ b = 2
+ c = 3
+ d = 4
+"""
+ ).body[0]
+ assert isinstance(func, ast.FunctionDef)
+ func.body[0].lineno = 0
+ blocks = extract_blocks(
+ func,
+ filepath="x.py",
+ qualname="mod:f",
+ cfg=NormalizationConfig(),
+ block_size=4,
+ max_blocks=10,
+ )
+ assert blocks == []
+
+
+def test_extract_blocks_max_blocks_limit() -> None:
+ func = ast.parse(
+ """
+def f():
+ a = 1
+ b = 2
+ c = 3
+ d = 4
+ e = 5
+ f = 6
+"""
+ ).body[0]
+ blocks = extract_blocks(
+ func,
+ filepath="x.py",
+ qualname="mod:f",
+ cfg=NormalizationConfig(),
+ block_size=2,
+ max_blocks=1,
+ )
+ assert len(blocks) == 1
diff --git a/tests/test_cache.py b/tests/test_cache.py
new file mode 100644
index 0000000..f0bca78
--- /dev/null
+++ b/tests/test_cache.py
@@ -0,0 +1,198 @@
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any, cast
+
+import pytest
+
+from codeclone.blocks import BlockUnit
+from codeclone.cache import Cache
+from codeclone.errors import CacheError
+from codeclone.extractor import Unit
+
+
+def _make_unit(filepath: str) -> Unit:
+ return Unit(
+ qualname="mod:func",
+ filepath=filepath,
+ start_line=1,
+ end_line=2,
+ loc=2,
+ stmt_count=1,
+ fingerprint="abc",
+ loc_bucket="0-19",
+ )
+
+
+def _make_block(filepath: str) -> BlockUnit:
+ return BlockUnit(
+ block_hash="h1",
+ filepath=filepath,
+ qualname="mod:func",
+ start_line=1,
+ end_line=2,
+ size=4,
+ )
+
+
+def test_cache_roundtrip(tmp_path: Path) -> None:
+ cache_path = tmp_path / "cache.json"
+ cache = Cache(cache_path)
+ unit = _make_unit("x.py")
+ block = _make_block("x.py")
+ cache.put_file_entry("x.py", {"mtime_ns": 1, "size": 10}, [unit], [block])
+ cache.save()
+
+ loaded = Cache(cache_path)
+ loaded.load()
+ entry = loaded.get_file_entry("x.py")
+ assert entry is not None
+ assert entry["stat"]["size"] == 10
+ assert entry["units"][0]["qualname"] == "mod:func"
+
+
+def test_cache_signature_mismatch_warns(tmp_path: Path) -> None:
+ cache_path = tmp_path / "cache.json"
+ cache = Cache(cache_path)
+ cache.put_file_entry("x.py", {"mtime_ns": 1, "size": 10}, [], [])
+ cache.save()
+
+ data = json.loads(cache_path.read_text("utf-8"))
+ data["_signature"] = "bad"
+ cache_path.write_text(json.dumps(data), "utf-8")
+
+ loaded = Cache(cache_path)
+ loaded.load()
+ assert loaded.load_warning is not None
+ assert "signature" in loaded.load_warning
+ assert loaded.data["version"] == Cache.CACHE_VERSION
+ assert loaded.data["files"] == {}
+
+
+def test_cache_version_mismatch_warns(tmp_path: Path) -> None:
+ cache_path = tmp_path / "cache.json"
+ cache = Cache(cache_path)
+ data = {"version": "0.0", "files": {}}
+ signature = cache._sign_data(data)
+ cache_path.write_text(
+ json.dumps({**data, "_signature": signature}, ensure_ascii=False, indent=2),
+ "utf-8",
+ )
+
+ loaded = Cache(cache_path)
+ loaded.load()
+ assert loaded.load_warning is not None
+ assert "version" in loaded.load_warning
+ assert loaded.data["version"] == Cache.CACHE_VERSION
+ assert loaded.data["files"] == {}
+
+
+def test_cache_entry_validation(tmp_path: Path) -> None:
+ cache_path = tmp_path / "cache.json"
+ cache = Cache(cache_path)
+ cache.data["files"]["x.py"] = cast(Any, {"stat": {"mtime_ns": 1, "size": 1}})
+ assert cache.get_file_entry("x.py") is None
+
+
+def test_cache_load_missing_file(tmp_path: Path) -> None:
+ cache_path = tmp_path / "missing.json"
+ cache = Cache(cache_path)
+ cache.load()
+ assert cache.load_warning is None
+
+
+def test_cache_entry_not_dict(tmp_path: Path) -> None:
+ cache_path = tmp_path / "cache.json"
+ cache = Cache(cache_path)
+ cache.data["files"]["x.py"] = cast(Any, ["bad"])
+ assert cache.get_file_entry("x.py") is None
+
+
+def test_cache_load_corrupted_json(tmp_path: Path) -> None:
+ cache_path = tmp_path / "cache.json"
+ cache_path.write_text("{invalid json", "utf-8")
+ cache = Cache(cache_path)
+ cache.load()
+ assert cache.load_warning is not None
+ assert "corrupted" in cache.load_warning
+
+
+def test_cache_load_invalid_files_type(tmp_path: Path) -> None:
+ cache_path = tmp_path / "cache.json"
+ cache = Cache(cache_path)
+ data = {"version": cache.CACHE_VERSION, "files": []}
+ signature = cache._sign_data(data)
+ cache_path.write_text(json.dumps({**data, "_signature": signature}), "utf-8")
+ cache.load()
+ assert cache.load_warning is not None
+ assert "format" in cache.load_warning
+
+
+def test_cache_save_error(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+ cache_path = tmp_path / "cache.json"
+ cache = Cache(cache_path)
+
+ original_write_text = Path.write_text
+
+ def _raise_write_text(
+ self: Path,
+ data: str,
+ encoding: str | None = None,
+ errors: str | None = None,
+ newline: str | None = None,
+ ) -> int:
+ if self == cache_path:
+ raise OSError("nope")
+ return original_write_text(
+ self, data, encoding=encoding, errors=errors, newline=newline
+ )
+
+ monkeypatch.setattr(Path, "write_text", _raise_write_text)
+
+ with pytest.raises(CacheError):
+ cache.save()
+
+
+def test_cache_secret_write_failure(
+ tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+ cache_path = tmp_path / "cache.json"
+ secret_path = cache_path.parent / ".cache_secret"
+ original_write_bytes = Path.write_bytes
+
+ def _raise_write_bytes(self: Path, data: bytes) -> int:
+ if self == secret_path:
+ raise OSError("nope")
+ return original_write_bytes(self, data)
+
+ monkeypatch.setattr(Path, "write_bytes", _raise_write_bytes)
+ cache = Cache(cache_path)
+ assert isinstance(cache.secret, bytes)
+ assert len(cache.secret) == 32
+
+
+def test_cache_secret_chmod_failure(
+ tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+ cache_path = tmp_path / "cache.json"
+ secret_path = cache_path.parent / ".cache_secret"
+
+ original_write_bytes = Path.write_bytes
+ original_chmod = Path.chmod
+
+ def _write_bytes(self: Path, data: bytes) -> int:
+ return original_write_bytes(self, data)
+
+ def _raise_chmod(self: Path, _mode: int) -> None:
+ if self == secret_path:
+ raise OSError("nope")
+ return original_chmod(self, _mode)
+
+ monkeypatch.setattr(Path, "write_bytes", _write_bytes)
+ monkeypatch.setattr(Path, "chmod", _raise_chmod)
+ monkeypatch.setattr(os, "name", "posix")
+
+ cache = Cache(cache_path)
+ assert isinstance(cache.secret, bytes)
diff --git a/tests/test_cfg.py b/tests/test_cfg.py
index 8c070dc..abe945d 100644
--- a/tests/test_cfg.py
+++ b/tests/test_cfg.py
@@ -1,7 +1,9 @@
import ast
from textwrap import dedent
-from codeclone.cfg import CFGBuilder, CFG
+import pytest
+
+from codeclone.cfg import CFG, CFGBuilder
def build_cfg_from_source(source: str) -> CFG:
@@ -21,11 +23,14 @@ def cfg_to_str(cfg: CFG) -> str:
succ = sorted(s.id for s in block.successors)
lines.append(f"Block {block.id} -> [{', '.join(map(str, succ))}]")
for stmt in block.statements:
- lines.append(f" {ast.dump(stmt)}")
+ dumped = ast.dump(stmt)
+ # Normalize across Python versions (empty Call keywords may be shown)
+ dumped = dumped.replace(", keywords=[]", "")
+ lines.append(f" {dumped}")
return "\n".join(lines)
-def test_cfg_if_else():
+def test_cfg_if_else() -> None:
source = """
def f(a):
if a > 0:
@@ -34,20 +39,24 @@ def f(a):
x = 2
"""
cfg_str = cfg_to_str(build_cfg_from_source(source))
- expected = """
-Block 0 -> [2, 3]
- Expr(value=Compare(left=Name(id='a', ctx=Load()), ops=[Gt()], comparators=[Constant(value=0)]))
-Block 1 -> []
-Block 2 -> [4]
- Assign(targets=[Name(id='x', ctx=Store())], value=Constant(value=1))
-Block 3 -> [4]
- Assign(targets=[Name(id='x', ctx=Store())], value=Constant(value=2))
-Block 4 -> [1]
-"""
+ expected = "\n".join(
+ [
+ "Block 0 -> [2, 3]",
+ " Expr(value=Compare(left=Name(id='a', ctx=Load()), ops=[Gt()], "
+ "comparators=[Constant(value=0)]))",
+ "Block 1 -> []",
+ "Block 2 -> [4]",
+ " Assign(targets=[Name(id='x', ctx=Store())], value=Constant(value=1))",
+ "Block 3 -> [4]",
+ " Assign(targets=[Name(id='x', ctx=Store())], value=Constant(value=2))",
+ "Block 4 -> [1]",
+ "",
+ ]
+ )
assert cfg_str.strip() == dedent(expected).strip()
-def test_cfg_while_loop():
+def test_cfg_while_loop() -> None:
source = """
def f():
while True:
@@ -66,7 +75,7 @@ def f():
assert cfg_str.strip() == dedent(expected).strip()
-def test_cfg_for_loop():
+def test_cfg_for_loop() -> None:
source = """
def f():
for i in range(10):
@@ -85,7 +94,7 @@ def f():
assert cfg_str.strip() == dedent(expected).strip()
-def test_cfg_break_continue():
+def test_cfg_break_continue() -> None:
source = """
def f():
for i in range(10):
@@ -133,7 +142,44 @@ def f():
assert isinstance(block.successors, set)
-def test_cfg_try_finally():
+def test_cfg_if_with_return() -> None:
+ source = """
+ def f(x):
+ if x > 0:
+ return 1
+ return 2
+ """
+ cfg = build_cfg_from_source(source)
+ assert any(
+ any(isinstance(stmt, ast.Return) for stmt in block.statements)
+ for block in cfg.blocks
+ )
+
+
+def test_cfg_raise_statement() -> None:
+ source = """
+ def f():
+ raise ValueError("x")
+ x = 1
+ """
+ cfg = build_cfg_from_source(source)
+ exits = [
+ b for b in cfg.blocks if any(isinstance(s, ast.Raise) for s in b.statements)
+ ]
+ assert len(exits) == 1
+
+
+def test_cfg_async_for() -> None:
+ source = """
+ async def f():
+ async for i in a:
+ x = i
+ """
+ cfg = build_cfg_from_source(source)
+ assert len(cfg.blocks) >= 4
+
+
+def test_cfg_try_finally() -> None:
source = """
def f():
try:
@@ -149,7 +195,112 @@ def f():
assert len(cfg.blocks) > 3
-def test_cfg_with():
+def test_cfg_try_else() -> None:
+ source = """
+ def f():
+ try:
+ x = 1
+ except ValueError:
+ pass
+ else:
+ y = 2
+ """
+ cfg = build_cfg_from_source(source)
+ has_else_assign = False
+ for block in cfg.blocks:
+ for stmt in block.statements:
+ if isinstance(stmt, ast.Assign) and any(
+ isinstance(t, ast.Name) and t.id == "y" for t in stmt.targets
+ ):
+ has_else_assign = True
+ assert has_else_assign
+
+
+def test_cfg_try_return_in_body() -> None:
+ source = """
+ def f():
+ try:
+ return 1
+ except ValueError:
+ pass
+ """
+ cfg = build_cfg_from_source(source)
+ assert any(
+ any(isinstance(stmt, ast.Return) for stmt in block.statements)
+ for block in cfg.blocks
+ )
+
+
+def test_cfg_if_else_returns() -> None:
+ source = """
+ def f(x):
+ if x:
+ return 1
+ else:
+ return 2
+ """
+ cfg = build_cfg_from_source(source)
+ assert any(
+ any(isinstance(stmt, ast.Return) for stmt in block.statements)
+ for block in cfg.blocks
+ )
+
+
+def test_cfg_while_return() -> None:
+ source = """
+ def f():
+ while True:
+ return 1
+ """
+ cfg = build_cfg_from_source(source)
+ assert any(
+ any(isinstance(stmt, ast.Return) for stmt in block.statements)
+ for block in cfg.blocks
+ )
+
+
+def test_cfg_for_return() -> None:
+ source = """
+ def f():
+ for i in range(3):
+ return i
+ """
+ cfg = build_cfg_from_source(source)
+ assert any(
+ any(isinstance(stmt, ast.Return) for stmt in block.statements)
+ for block in cfg.blocks
+ )
+
+
+def test_cfg_with_return() -> None:
+ source = """
+ def f():
+ with open(\"x\", \"w\") as f:
+ return 1
+ """
+ cfg = build_cfg_from_source(source)
+ assert any(
+ any(isinstance(stmt, ast.Return) for stmt in block.statements)
+ for block in cfg.blocks
+ )
+
+
+def test_cfg_try_handler_no_type() -> None:
+ source = """
+ def f():
+ try:
+ x = 1
+ except:
+ return 2
+ """
+ cfg = build_cfg_from_source(source)
+ assert any(
+ any(isinstance(stmt, ast.Return) for stmt in block.statements)
+ for block in cfg.blocks
+ )
+
+
+def test_cfg_with() -> None:
source = """
def f():
with open("x") as f:
@@ -159,7 +310,7 @@ def f():
assert len(cfg.blocks) >= 3
-def test_cfg_match():
+def test_cfg_match() -> None:
source = """
def f(x):
match x:
@@ -174,3 +325,93 @@ def f(x):
except SyntaxError:
# Python < 3.10
pass
+
+
+def test_cfg_try_handler_linking() -> None:
+ """Test that statements inside try block are linked to handlers."""
+ code = """
+ def f():
+ try:
+ x = 1
+ y = 2
+ except ValueError:
+ pass
+ """
+ func = ast.parse(dedent(code)).body[0]
+ assert isinstance(func, (ast.FunctionDef, ast.AsyncFunctionDef))
+ builder = CFGBuilder()
+ cfg = builder.build("f", func)
+
+ handler_blocks = [
+ b
+ for b in cfg.blocks
+ if any(
+ isinstance(s, ast.Expr)
+ and isinstance(s.value, ast.Name)
+ and s.value.id == "ValueError"
+ for s in b.statements
+ )
+ ]
+
+ assert len(handler_blocks) == 1
+ handler_block = handler_blocks[0]
+
+ predecessors = [b for b in cfg.blocks if handler_block in b.successors]
+
+ has_assignment = False
+ for pred in predecessors:
+ for stmt in pred.statements:
+ if isinstance(stmt, ast.Assign):
+ has_assignment = True
+
+ assert has_assignment, "Handler should be reachable from assignment block"
+
+
+def test_cfg_try_star() -> None:
+ code = """
+ def f():
+ try:
+ x = 1
+ except* ValueError:
+ pass
+ """
+ try:
+ func = ast.parse(dedent(code)).body[0]
+ except SyntaxError:
+ pytest.skip("TryStar not supported")
+
+ assert isinstance(func, (ast.FunctionDef, ast.AsyncFunctionDef))
+ cfg = CFGBuilder().build("f", func)
+ assert len(cfg.blocks) >= 3
+
+
+def test_cfg_match_pattern() -> None:
+ """Test that match pattern is recorded in CFG."""
+ code = """
+ def f(x):
+ match x:
+ case [1, 2]:
+ pass
+ case {"a": 1}:
+ pass
+ """
+ try:
+ func = ast.parse(dedent(code)).body[0]
+ except SyntaxError:
+ pytest.skip("SyntaxError parsing match (old python?)")
+
+ assert isinstance(func, (ast.FunctionDef, ast.AsyncFunctionDef))
+ builder = CFGBuilder()
+ cfg = builder.build("f", func)
+
+ patterns_found = []
+ for block in cfg.blocks:
+ for stmt in block.statements:
+ if isinstance(stmt, ast.Expr) and isinstance(stmt.value, ast.Constant):
+ val = stmt.value.value
+ if isinstance(val, str) and val.startswith("PATTERN:"):
+ patterns_found.append(val)
+
+ assert len(patterns_found) == 2
+ assert "MatchSequence" in patterns_found[0]
+ assert "MatchMapping" in patterns_found[1]
diff --git a/tests/test_cfg_model.py b/tests/test_cfg_model.py
new file mode 100644
index 0000000..216c9a8
--- /dev/null
+++ b/tests/test_cfg_model.py
@@ -0,0 +1,18 @@
+from codeclone.cfg_model import CFG, Block
+
+
+def test_block_hash_and_eq() -> None:
+ b1 = Block(id=1)
+ b2 = Block(id=1)
+ b3 = Block(id=2)
+ assert b1 == b2
+ assert b1 != b3
+ assert hash(b1) == hash(b2)
+
+
+def test_cfg_create_block() -> None:
+ cfg = CFG("f")
+ count = len(cfg.blocks)
+ b = cfg.create_block()
+ assert len(cfg.blocks) == count + 1
+ assert b.id == count
diff --git a/tests/test_cli_inprocess.py b/tests/test_cli_inprocess.py
new file mode 100644
index 0000000..f9c7a47
--- /dev/null
+++ b/tests/test_cli_inprocess.py
@@ -0,0 +1,812 @@
+from __future__ import annotations
+
+import json
+import sys
+from collections.abc import Callable, Iterable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal
+
+import pytest
+
+import codeclone.baseline as baseline
+from codeclone import cli
+from codeclone.cache import Cache
+from codeclone.errors import CacheError
+
+
+@dataclass(slots=True)
+class _DummyFuture:
+ _result: object
+
+ def result(self) -> object:
+ return self._result
+
+
+class _DummyExecutor:
+ def __init__(self, max_workers: int | None = None) -> None:
+ self.max_workers = max_workers
+
+ def __enter__(self) -> _DummyExecutor:
+ return self
+
+ def __exit__(
+ self,
+ exc_type: type[BaseException] | None,
+ exc: BaseException | None,
+ tb: object | None,
+ ) -> Literal[False]:
+ return False
+
+ def submit(
+ self, fn: Callable[..., object], *args: object, **kwargs: object
+ ) -> _DummyFuture:
+ return _DummyFuture(fn(*args, **kwargs))
+
+
+class _FailingExecutor:
+ def __init__(self, max_workers: int | None = None) -> None:
+ self.max_workers = max_workers
+
+ def __enter__(self) -> _FailingExecutor:
+ raise PermissionError("nope")
+
+ def __exit__(
+ self,
+ exc_type: type[BaseException] | None,
+ exc: BaseException | None,
+ tb: object | None,
+ ) -> Literal[False]:
+ return False
+
+
+def _patch_parallel(monkeypatch: pytest.MonkeyPatch) -> None:
+ monkeypatch.setattr(cli, "ProcessPoolExecutor", _DummyExecutor)
+ monkeypatch.setattr(cli, "as_completed", lambda futures: futures)
+
+
+def _run_main(monkeypatch: pytest.MonkeyPatch, args: Iterable[str]) -> None:
+ monkeypatch.setattr(sys, "argv", ["codeclone", *args])
+ cli.main()
+
+
+def test_cli_main_no_progress_parallel(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+ capsys: pytest.CaptureFixture[str],
+) -> None:
+ src = tmp_path / "a.py"
+ src.write_text(
+ """
+def f1():
+ print("hello")
+ return 1
+
+def f2():
+ print("hello")
+ return 1
+""",
+ "utf-8",
+ )
+ _patch_parallel(monkeypatch)
+ _run_main(
+ monkeypatch,
+ [
+ str(tmp_path),
+ "--min-loc",
+ "1",
+ "--min-stmt",
+ "1",
+ "--no-progress",
+ ],
+ )
+ out = capsys.readouterr().out
+ assert "Total Function Clones" in out
+
+
+def test_cli_main_progress_fallback(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+ capsys: pytest.CaptureFixture[str],
+) -> None:
+ src = tmp_path / "a.py"
+ src.write_text("def f():\n return 1\n", "utf-8")
+ monkeypatch.setattr(cli, "ProcessPoolExecutor", _FailingExecutor)
+ _run_main(monkeypatch, [str(tmp_path)])
+ out = capsys.readouterr().out
+ assert "falling back to sequential" in out
+
+
+def test_cli_main_progress_path(
+ tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+ src = tmp_path / "a.py"
+ src.write_text("def f():\n return 1\n", "utf-8")
+
+ class _DummyProgress:
+ def __init__(self, *args: object, **kwargs: object) -> None:
+ return None
+
+ def __enter__(self) -> _DummyProgress:
+ return self
+
+ def __exit__(
+ self,
+ exc_type: type[BaseException] | None,
+ exc: BaseException | None,
+ tb: object | None,
+ ) -> Literal[False]:
+ return False
+
+ def add_task(self, _desc: str, total: int) -> int:
+ return total
+
+ def advance(self, _task: int) -> None:
+ return None
+
+ monkeypatch.setattr(cli, "Progress", _DummyProgress)
+ _patch_parallel(monkeypatch)
+ _run_main(monkeypatch, [str(tmp_path)])
+
+
+def test_cli_invalid_root_exception(monkeypatch: pytest.MonkeyPatch) -> None:
+ def _boom(self: Path) -> Path:
+ raise OSError("bad")
+
+ monkeypatch.setattr(Path, "resolve", _boom)
+ with pytest.raises(SystemExit) as exc:
+ _run_main(monkeypatch, ["bad"])
+ assert exc.value.code == 1
+
+
+def test_cli_main_outputs(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+ src = tmp_path / "a.py"
+ src.write_text("def f():\n return 1\n", "utf-8")
+ html_out = tmp_path / "out.html"
+ json_out = tmp_path / "out.json"
+ text_out = tmp_path / "out.txt"
+ _patch_parallel(monkeypatch)
+ _run_main(
+ monkeypatch,
+ [
+ str(tmp_path),
+ "--html",
+ str(html_out),
+ "--json",
+ str(json_out),
+ "--text",
+ str(text_out),
+ "--no-progress",
+ ],
+ )
+ assert html_out.exists()
+ assert json_out.exists()
+ assert text_out.exists()
+
+
+def test_cli_update_baseline(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+ capsys: pytest.CaptureFixture[str],
+) -> None:
+ src = tmp_path / "a.py"
+ src.write_text(
+ """
+def f1():
+ return 1
+
+def f2():
+ return 1
+""",
+ "utf-8",
+ )
+ baseline = tmp_path / "codeclone.baseline.json"
+ _patch_parallel(monkeypatch)
+ _run_main(
+ monkeypatch,
+ [
+ str(tmp_path),
+ "--baseline",
+ str(baseline),
+ "--update-baseline",
+ "--min-loc",
+ "1",
+ "--min-stmt",
+ "1",
+ "--no-progress",
+ ],
+ )
+ out = capsys.readouterr().out
+ assert "Baseline updated" in out
+ assert baseline.exists()
+
+
+def test_cli_baseline_missing_warning(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+ capsys: pytest.CaptureFixture[str],
+) -> None:
+ src = tmp_path / "a.py"
+ src.write_text("def f():\n return 1\n", "utf-8")
+ baseline = tmp_path / "missing.json"
+ _patch_parallel(monkeypatch)
+ _run_main(
+ monkeypatch,
+ [
+ str(tmp_path),
+ "--baseline",
+ str(baseline),
+ "--no-progress",
+ ],
+ )
+ out = capsys.readouterr().out
+ assert "Baseline file not found" in out
+
+
+def test_cli_new_clones_warning(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+ capsys: pytest.CaptureFixture[str],
+) -> None:
+ src = tmp_path / "a.py"
+ src.write_text(
+ """
+def f1():
+ return 1
+
+def f2():
+ return 1
+""",
+ "utf-8",
+ )
+ baseline = tmp_path / "baseline.json"
+ baseline.write_text('{"functions": [], "blocks": []}', "utf-8")
+ _patch_parallel(monkeypatch)
+ _run_main(
+ monkeypatch,
+ [
+ str(tmp_path),
+ "--baseline",
+ str(baseline),
+ "--min-loc",
+ "1",
+ "--min-stmt",
+ "1",
+ "--no-progress",
+ ],
+ )
+ out = capsys.readouterr().out
+ assert "New clones detected but --fail-on-new not set" in out
+
+
+def test_cli_baseline_python_version_mismatch_warns(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+ capsys: pytest.CaptureFixture[str],
+) -> None:
+ src = tmp_path / "a.py"
+ src.write_text("def f():\n return 1\n", "utf-8")
+ baseline = tmp_path / "baseline.json"
+ baseline.write_text(
+ '{"functions": [], "blocks": [], "python_version": "0.0"}', "utf-8"
+ )
+ _patch_parallel(monkeypatch)
+ _run_main(
+ monkeypatch,
+ [
+ str(tmp_path),
+ "--baseline",
+ str(baseline),
+ "--no-progress",
+ ],
+ )
+ out = capsys.readouterr().out
+ assert "Baseline was generated with Python 0.0." in out
+ assert "Current interpreter: Python" in out
+
+
+def test_cli_baseline_python_version_mismatch_fails(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+ capsys: pytest.CaptureFixture[str],
+) -> None:
+ src = tmp_path / "a.py"
+ src.write_text("def f():\n return 1\n", "utf-8")
+ baseline = tmp_path / "baseline.json"
+ baseline.write_text(
+ '{"functions": [], "blocks": [], "python_version": "0.0"}', "utf-8"
+ )
+ _patch_parallel(monkeypatch)
+ with pytest.raises(SystemExit) as exc:
+ _run_main(
+ monkeypatch,
+ [
+ str(tmp_path),
+ "--baseline",
+ str(baseline),
+ "--fail-on-new",
+ "--no-progress",
+ ],
+ )
+ assert exc.value.code == 2
+ out = capsys.readouterr().out
+ assert "Baseline checks require the same Python version" in out
+
+
+def test_cli_main_fail_threshold(
+ tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+ src = tmp_path / "a.py"
+ src.write_text(
+ """
+def f1():
+ return 1
+
+def f2():
+ return 1
+""",
+ "utf-8",
+ )
+ _patch_parallel(monkeypatch)
+ with pytest.raises(SystemExit) as exc:
+ _run_main(
+ monkeypatch,
+ [
+ str(tmp_path),
+ "--min-loc",
+ "1",
+ "--min-stmt",
+ "1",
+ "--fail-threshold",
+ "0",
+ "--no-progress",
+ ],
+ )
+ assert exc.value.code == 2
+
+
+def test_cli_main_fail_on_new(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+ src = tmp_path / "a.py"
+ src.write_text(
+ """
+def f1():
+ return 1
+
+def f2():
+ return 1
+ """,
+ "utf-8",
+ )
+ baseline = tmp_path / "baseline.json"
+ baseline.write_text(
+ json.dumps(
+ {
+ "functions": [],
+ "blocks": [],
+ "python_version": f"{sys.version_info.major}.{sys.version_info.minor}",
+ }
+ ),
+ "utf-8",
+ )
+ _patch_parallel(monkeypatch)
+ with pytest.raises(SystemExit) as exc:
+ _run_main(
+ monkeypatch,
+ [
+ str(tmp_path),
+ "--baseline",
+ str(baseline),
+ "--min-loc",
+ "1",
+ "--min-stmt",
+ "1",
+ "--fail-on-new",
+ "--no-progress",
+ ],
+ )
+ assert exc.value.code == 3
+
+
+def test_cli_blocks_processing(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+ body = "\n".join([f" x{i} = {i}" for i in range(60)])
+ src = tmp_path / "a.py"
+ src.write_text(f"\n\ndef f():\n{body}\n", "utf-8")
+ _patch_parallel(monkeypatch)
+ _run_main(
+ monkeypatch,
+ [str(tmp_path), "--min-loc", "1", "--min-stmt", "1", "--no-progress"],
+ )
+
+
+def test_cli_cache_warning(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+ capsys: pytest.CaptureFixture[str],
+) -> None:
+ src = tmp_path / "a.py"
+ src.write_text("def f():\n return 1\n", "utf-8")
+ cache_path = tmp_path / "cache.json"
+ cache = Cache(cache_path)
+ cache.put_file_entry("x.py", {"mtime_ns": 1, "size": 1}, [], [])
+ cache.save()
+ data = json.loads(cache_path.read_text("utf-8"))
+ data["_signature"] = "bad"
+ cache_path.write_text(json.dumps(data), "utf-8")
+
+ _patch_parallel(monkeypatch)
+ _run_main(
+ monkeypatch,
+ [
+ str(tmp_path),
+ "--cache-dir",
+ str(cache_path),
+ "--no-progress",
+ ],
+ )
+ out = capsys.readouterr().out
+ assert "Cache signature mismatch" in out
+
+
+def test_cli_cache_save_warning(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+ capsys: pytest.CaptureFixture[str],
+) -> None:
+ src = tmp_path / "a.py"
+ src.write_text("def f():\n return 1\n", "utf-8")
+
+ def _raise_save(self: Cache) -> None:
+ raise CacheError("nope")
+
+ monkeypatch.setattr(Cache, "save", _raise_save)
+ _patch_parallel(monkeypatch)
+ _run_main(
+ monkeypatch,
+ [
+ str(tmp_path),
+ "--no-progress",
+ ],
+ )
+ out = capsys.readouterr().out
+ assert "Failed to save cache" in out
+
+
+def test_cli_invalid_root(monkeypatch: pytest.MonkeyPatch) -> None:
+ with pytest.raises(SystemExit) as exc:
+ _run_main(monkeypatch, ["/path/does/not/exist"])
+ assert exc.value.code == 1
+
+
+def test_cli_discovery_cache_hit(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+ capsys: pytest.CaptureFixture[str],
+) -> None:
+ src = tmp_path / "a.py"
+ src.write_text("def f():\n return 1\n", "utf-8")
+
+ cache = Cache(tmp_path / "cache.json")
+ cache.data["files"][str(src)] = {
+ "stat": {"mtime_ns": src.stat().st_mtime_ns, "size": src.stat().st_size},
+ "units": [
+ {
+ "qualname": "mod:f",
+ "filepath": str(src),
+ "start_line": 1,
+ "end_line": 2,
+ "loc": 2,
+ "stmt_count": 1,
+ "fingerprint": "abc",
+ "loc_bucket": "0-19",
+ }
+ ],
+ "blocks": [],
+ }
+ cache.save()
+
+ _patch_parallel(monkeypatch)
+ _run_main(
+ monkeypatch,
+ [
+ str(tmp_path),
+ "--cache-dir",
+ str(cache.path),
+ "--no-progress",
+ ],
+ )
+ out = capsys.readouterr().out
+ assert "Files Processed" in out
+
+
+def test_cli_discovery_skip_oserror(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+ capsys: pytest.CaptureFixture[str],
+) -> None:
+ src = tmp_path / "a.py"
+ src.write_text("def f():\n return 1\n", "utf-8")
+
+ def _bad_stat(_path: str) -> dict[str, int]:
+ raise OSError("nope")
+
+ monkeypatch.setattr(cli, "file_stat_signature", _bad_stat)
+ _patch_parallel(monkeypatch)
+ _run_main(monkeypatch, [str(tmp_path), "--no-progress"])
+ out = capsys.readouterr().out
+ assert "Skipping file" in out
+
+
+def test_cli_scan_failed(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+ def _boom(_root: str) -> Iterable[str]:
+ raise RuntimeError("scan failed")
+
+ monkeypatch.setattr(cli, "iter_py_files", _boom)
+ with pytest.raises(SystemExit) as exc:
+ _run_main(monkeypatch, [str(tmp_path)])
+ assert exc.value.code == 1
+
+
+def test_cli_failed_files_report(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+ capsys: pytest.CaptureFixture[str],
+) -> None:
+ for i in range(12):
+ (tmp_path / f"f{i}.py").write_text("def f():\n return 1\n", "utf-8")
+
+ def _bad_process(
+ _fp: str, *_args: object, **_kwargs: object
+ ) -> cli.ProcessingResult:
+ return cli.ProcessingResult(filepath=_fp, success=False, error="bad")
+
+ monkeypatch.setattr(cli, "process_file", _bad_process)
+ _patch_parallel(monkeypatch)
+ _run_main(monkeypatch, [str(tmp_path), "--no-progress"])
+ out = capsys.readouterr().out
+ assert "files failed to process" in out
+ assert "and 2 more" in out
+
+
+def test_cli_worker_failed(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+ capsys: pytest.CaptureFixture[str],
+) -> None:
+ src = tmp_path / "a.py"
+ src.write_text("def f():\n return 1\n", "utf-8")
+
+ def _boom(*_args: object, **_kwargs: object) -> cli.ProcessingResult:
+ raise RuntimeError("boom")
+
+ monkeypatch.setattr(cli, "process_file", _boom)
+ _patch_parallel(monkeypatch)
+ _run_main(monkeypatch, [str(tmp_path), "--no-progress"])
+ out = capsys.readouterr().out
+ assert "Worker failed" in out
+
+
+def test_cli_worker_failed_progress_sequential(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+ capsys: pytest.CaptureFixture[str],
+) -> None:
+ src = tmp_path / "a.py"
+ src.write_text("def f():\n return 1\n", "utf-8")
+
+ def _boom(*_args: object, **_kwargs: object) -> cli.ProcessingResult:
+ raise RuntimeError("boom")
+
+ class _FailExec:
+ def __init__(self, *args: object, **kwargs: object) -> None:
+ return None
+
+ def __enter__(self) -> _FailExec:
+ raise PermissionError("nope")
+
+ def __exit__(
+ self,
+ exc_type: type[BaseException] | None,
+ exc: BaseException | None,
+ tb: object | None,
+ ) -> Literal[False]:
+ return False
+
+ class _DummyProgress:
+ def __init__(self, *args: object, **kwargs: object) -> None:
+ return None
+
+ def __enter__(self) -> _DummyProgress:
+ return self
+
+ def __exit__(
+ self,
+ exc_type: type[BaseException] | None,
+ exc: BaseException | None,
+ tb: object | None,
+ ) -> Literal[False]:
+ return False
+
+ def add_task(self, _desc: str, total: int) -> int:
+ return total
+
+ def advance(self, _task: int) -> None:
+ return None
+
+ monkeypatch.setattr(cli, "Progress", _DummyProgress)
+ monkeypatch.setattr(cli, "ProcessPoolExecutor", _FailExec)
+ monkeypatch.setattr(cli, "process_file", _boom)
+ _run_main(monkeypatch, [str(tmp_path)])
+ out = capsys.readouterr().out
+ assert "Worker failed" in out
+
+
+def test_cli_worker_failed_sequential_no_progress(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+ capsys: pytest.CaptureFixture[str],
+) -> None:
+ src = tmp_path / "a.py"
+ src.write_text("def f():\n return 1\n", "utf-8")
+
+ def _boom(*_args: object, **_kwargs: object) -> cli.ProcessingResult:
+ raise RuntimeError("boom")
+
+ class _FailExec:
+ def __init__(self, *args: object, **kwargs: object) -> None:
+ return None
+
+ def __enter__(self) -> _FailExec:
+ raise PermissionError("nope")
+
+ def __exit__(
+ self,
+ exc_type: type[BaseException] | None,
+ exc: BaseException | None,
+ tb: object | None,
+ ) -> Literal[False]:
+ return False
+
+ monkeypatch.setattr(cli, "ProcessPoolExecutor", _FailExec)
+ monkeypatch.setattr(cli, "process_file", _boom)
+ _run_main(monkeypatch, [str(tmp_path), "--no-progress"])
+ out = capsys.readouterr().out
+ assert "Worker failed" in out
+
+
+def test_cli_fail_on_new_prints_groups(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+ capsys: pytest.CaptureFixture[str],
+) -> None:
+ src = tmp_path / "a.py"
+ src.write_text("def f():\n return 1\n", "utf-8")
+
+ def _diff(
+ _self: object, _f: dict[str, object], _b: dict[str, object]
+ ) -> tuple[set[str], set[str]]:
+ return {"f1"}, {"b1"}
+
+ monkeypatch.setattr(baseline.Baseline, "diff", _diff)
+ baseline_path = tmp_path / "baseline.json"
+ baseline_path.write_text(
+ json.dumps(
+ {
+ "functions": [],
+ "blocks": [],
+ "python_version": f"{sys.version_info.major}.{sys.version_info.minor}",
+ }
+ ),
+ "utf-8",
+ )
+ _patch_parallel(monkeypatch)
+ with pytest.raises(SystemExit) as exc:
+ _run_main(
+ monkeypatch,
+ [
+ str(tmp_path),
+ "--baseline",
+ str(baseline_path),
+ "--fail-on-new",
+ "--no-progress",
+ ],
+ )
+ assert exc.value.code == 3
+ out = capsys.readouterr().out
+ assert "New Functions" in out
+ assert "New Blocks" in out
+
+
+def test_cli_failed_batch_item_no_progress(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+ capsys: pytest.CaptureFixture[str],
+) -> None:
+ src = tmp_path / "a.py"
+ src.write_text("def f():\n return 1\n", "utf-8")
+
+ class _Future:
+ def result(self) -> cli.ProcessingResult:
+ raise RuntimeError("boom")
+
+ class _Exec:
+ def __init__(self, *args: object, **kwargs: object) -> None:
+ return None
+
+ def __enter__(self) -> _Exec:
+ return self
+
+ def __exit__(
+ self,
+ exc_type: type[BaseException] | None,
+ exc: BaseException | None,
+ tb: object | None,
+ ) -> Literal[False]:
+ return False
+
+ def submit(self, *_args: object, **_kwargs: object) -> _Future:
+ return _Future()
+
+ monkeypatch.setattr(cli, "ProcessPoolExecutor", _Exec)
+ monkeypatch.setattr(cli, "as_completed", lambda futures: futures)
+ _run_main(monkeypatch, [str(tmp_path), "--no-progress"])
+ out = capsys.readouterr().out
+ assert "Failed to process batch item" in out
+
+
+def test_cli_failed_batch_item_progress(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+ capsys: pytest.CaptureFixture[str],
+) -> None:
+ src = tmp_path / "a.py"
+ src.write_text("def f():\n return 1\n", "utf-8")
+
+ class _Future:
+ def result(self) -> cli.ProcessingResult:
+ raise RuntimeError("boom")
+
+ class _Exec:
+ def __init__(self, *args: object, **kwargs: object) -> None:
+ return None
+
+ def __enter__(self) -> _Exec:
+ return self
+
+ def __exit__(
+ self,
+ exc_type: type[BaseException] | None,
+ exc: BaseException | None,
+ tb: object | None,
+ ) -> Literal[False]:
+ return False
+
+ def submit(self, *_args: object, **_kwargs: object) -> _Future:
+ return _Future()
+
+ class _DummyProgress:
+ def __init__(self, *args: object, **kwargs: object) -> None:
+ return None
+
+ def __enter__(self) -> _DummyProgress:
+ return self
+
+ def __exit__(
+ self,
+ exc_type: type[BaseException] | None,
+ exc: BaseException | None,
+ tb: object | None,
+ ) -> Literal[False]:
+ return False
+
+ def add_task(self, _desc: str, total: int) -> int:
+ return total
+
+ def advance(self, _task: int) -> None:
+ return None
+
+ monkeypatch.setattr(cli, "Progress", _DummyProgress)
+ monkeypatch.setattr(cli, "ProcessPoolExecutor", _Exec)
+ monkeypatch.setattr(cli, "as_completed", lambda futures: futures)
+ _run_main(monkeypatch, [str(tmp_path)])
+ out = capsys.readouterr().out
+ assert "Worker failed" in out or "Failed to process batch item" in out
diff --git a/tests/test_cli_main_guard.py b/tests/test_cli_main_guard.py
new file mode 100644
index 0000000..3570d68
--- /dev/null
+++ b/tests/test_cli_main_guard.py
@@ -0,0 +1,17 @@
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+
+def test_cli_main_guard_runs() -> None:
+ root_dir = Path(__file__).parents[1]
+ env = os.environ.copy()
+ env["PYTHONPATH"] = str(root_dir) + os.pathsep + env.get("PYTHONPATH", "")
+ result = subprocess.run(
+ [sys.executable, "-m", "codeclone.cli", "--help"],
+ capture_output=True,
+ text=True,
+ env=env,
+ )
+ assert result.returncode == 0
diff --git a/tests/test_cli_smoke.py b/tests/test_cli_smoke.py
index 359ffe7..603ea77 100644
--- a/tests/test_cli_smoke.py
+++ b/tests/test_cli_smoke.py
@@ -1,10 +1,13 @@
+import os
import subprocess
import sys
-import os
+from collections.abc import Iterable
from pathlib import Path
-def run_cli(args, cwd=None):
+def run_cli(
+ args: Iterable[str], cwd: Path | None = None
+) -> subprocess.CompletedProcess[str]:
env = os.environ.copy()
root_dir = Path(__file__).parents[1]
env["PYTHONPATH"] = str(root_dir) + os.pathsep + env.get("PYTHONPATH", "")
@@ -14,7 +17,7 @@ def run_cli(args, cwd=None):
executable = str(venv_python) if venv_python.exists() else sys.executable
return subprocess.run(
- [executable, "-m", "codeclone.cli"] + args,
+ [executable, "-m", "codeclone.cli", *args],
capture_output=True,
text=True,
cwd=cwd,
@@ -22,7 +25,7 @@ def run_cli(args, cwd=None):
)
-def test_cli_runs(tmp_path: Path):
+def test_cli_runs(tmp_path: Path) -> None:
src = tmp_path / "a.py"
src.write_text(
"""
@@ -39,7 +42,7 @@ def f():
assert "Total Function Clones" in result.stdout
-def test_cli_baseline_missing_warning(tmp_path: Path):
+def test_cli_baseline_missing_warning(tmp_path: Path) -> None:
# Should print a warning when baseline is missing and --update-baseline is not set
src = tmp_path / "a.py"
src.write_text("def f(): pass")
@@ -53,7 +56,7 @@ def test_cli_baseline_missing_warning(tmp_path: Path):
assert baseline_file.name in result.stdout
-def test_cli_update_baseline(tmp_path: Path):
+def test_cli_update_baseline(tmp_path: Path) -> None:
src = tmp_path / "a.py"
# Create two identical functions to trigger a clone
src.write_text("""
diff --git a/tests/test_cli_unit.py b/tests/test_cli_unit.py
new file mode 100644
index 0000000..85bbf31
--- /dev/null
+++ b/tests/test_cli_unit.py
@@ -0,0 +1,69 @@
+import os
+from pathlib import Path
+
+import pytest
+
+import codeclone.cli as cli
+from codeclone.cli import expand_path, process_file
+from codeclone.normalize import NormalizationConfig
+
+
+def test_expand_path() -> None:
+ p = expand_path(".")
+ assert isinstance(p, Path)
+
+
+def test_process_file_stat_error(
+ monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+ src = tmp_path / "a.py"
+ src.write_text("def f():\n return 1\n", "utf-8")
+
+ def _boom(_path: str) -> int:
+ raise OSError("nope")
+
+ monkeypatch.setattr(os.path, "getsize", _boom)
+ result = process_file(str(src), str(tmp_path), NormalizationConfig(), 1, 1)
+ assert result.success is False
+ assert result.error is not None
+ assert "Cannot stat file" in result.error
+
+
+def test_process_file_encoding_error(
+ monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+ src = tmp_path / "a.py"
+ src.write_bytes(b"\xff\xfe\xff")
+
+ def _boom(*_args: object, **_kwargs: object) -> str:
+ raise UnicodeDecodeError("utf-8", b"\xff", 0, 1, "bad")
+
+ monkeypatch.setattr(Path, "read_text", _boom)
+ result = process_file(str(src), str(tmp_path), NormalizationConfig(), 1, 1)
+ assert result.success is False
+ assert result.error is not None
+ assert "Encoding error" in result.error
+
+
+def test_process_file_unexpected_error(
+ monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+ src = tmp_path / "a.py"
+ src.write_text("def f():\n return 1\n", "utf-8")
+
+ def _boom(*_args: object, **_kwargs: object) -> object:
+ raise RuntimeError("boom")
+
+ monkeypatch.setattr(cli, "extract_units_from_source", _boom)
+ result = process_file(str(src), str(tmp_path), NormalizationConfig(), 1, 1)
+ assert result.success is False
+ assert result.error is not None
+ assert "Unexpected error" in result.error
+
+
+def test_process_file_success(tmp_path: Path) -> None:
+ src = tmp_path / "a.py"
+ src.write_text("def f():\n return 1\n", "utf-8")
+ result = process_file(str(src), str(tmp_path), NormalizationConfig(), 1, 1)
+ assert result.success is True
+ assert result.stat is not None
diff --git a/tests/test_extractor.py b/tests/test_extractor.py
index b1686e9..6eeaebe 100644
--- a/tests/test_extractor.py
+++ b/tests/test_extractor.py
@@ -1,9 +1,21 @@
+import ast
+import os
+import signal
+import sys
+from collections.abc import Callable, Iterator
+from contextlib import contextmanager
+
+import pytest
+
+from codeclone import extractor
+from codeclone.errors import ParseError
from codeclone.extractor import extract_units_from_source
from codeclone.normalize import NormalizationConfig
-def test_extracts_function_unit():
+def test_extracts_function_unit() -> None:
src = """
+
def foo():
a = 1
b = 2
@@ -26,7 +38,7 @@ def foo():
assert blocks == []
-def test_init_function_is_ignored_for_blocks():
+def test_init_function_is_ignored_for_blocks() -> None:
src = """
class A:
def __init__(self):
@@ -47,3 +59,154 @@ def __init__(self):
assert len(units) == 1
assert blocks == []
+
+
+def test_parse_timeout_raises(monkeypatch: pytest.MonkeyPatch) -> None:
+ @contextmanager
+ def _boom(_timeout_s: int) -> Iterator[None]:
+ raise extractor._ParseTimeoutError("AST parsing timeout")
+ if False:
+ yield
+
+ monkeypatch.setattr(extractor, "_parse_limits", _boom)
+
+ with pytest.raises(ParseError, match="AST parsing timeout"):
+ extractor._parse_with_limits("x = 1", 1)
+
+
+def test_parse_limits_no_timeout() -> None:
+ with extractor._parse_limits(0):
+ tree = extractor._parse_with_limits("x = 1", 0)
+ assert tree is not None
+
+
+def test_parse_limits_resource_failure(monkeypatch: pytest.MonkeyPatch) -> None:
+ class _DummyResource:
+ RLIMIT_CPU = 0
+ RLIM_INFINITY = 10**9
+
+ @staticmethod
+ def getrlimit(_key: int) -> tuple[int, int]:
+ raise RuntimeError("nope")
+
+ @staticmethod
+ def setrlimit(_key: int, _val: tuple[int, int]) -> None:
+ return None
+
+ monkeypatch.setattr(os, "name", "posix")
+ monkeypatch.setattr(signal, "getsignal", lambda *_args, **_kwargs: None)
+ monkeypatch.setattr(signal, "signal", lambda *_args, **_kwargs: None)
+ monkeypatch.setattr(signal, "setitimer", lambda *_args, **_kwargs: None)
+ monkeypatch.setitem(sys.modules, "resource", _DummyResource)
+
+ with extractor._parse_limits(1):
+ tree = extractor._parse_with_limits("x = 1", 1)
+ assert tree is not None
+
+
+def test_extract_syntax_error() -> None:
+ with pytest.raises(ParseError):
+ extract_units_from_source(
+ source="def f(:\n pass",
+ filepath="x.py",
+ module_name="mod",
+ cfg=NormalizationConfig(),
+ min_loc=1,
+ min_stmt=1,
+ )
+
+
+def test_extract_respects_min_loc_min_stmt() -> None:
+ src = """
+
+def f():
+ x = 1
+"""
+ units, blocks = extract_units_from_source(
+ source=src,
+ filepath="x.py",
+ module_name="mod",
+ cfg=NormalizationConfig(),
+ min_loc=10,
+ min_stmt=10,
+ )
+ assert units == []
+ assert blocks == []
+
+
+def test_extract_block_units_generated() -> None:
+ body_lines = "\n".join([f" x{i} = {i}" for i in range(50)])
+ src = f"""
+
+def f():
+{body_lines}
+"""
+ units, blocks = extract_units_from_source(
+ source=src,
+ filepath="x.py",
+ module_name="mod",
+ cfg=NormalizationConfig(),
+ min_loc=1,
+ min_stmt=1,
+ )
+ assert units
+ assert blocks
+
+
+def test_extract_async_function() -> None:
+ src = """
+async def af():
+ return 1
+"""
+ units, blocks = extract_units_from_source(
+ source=src,
+ filepath="x.py",
+ module_name="mod",
+ cfg=NormalizationConfig(),
+ min_loc=1,
+ min_stmt=1,
+ )
+ assert len(units) == 1
+ assert blocks == []
+
+
+def test_extract_skips_invalid_positions(monkeypatch: pytest.MonkeyPatch) -> None:
+ tree = ast.parse(
+ """
+def f():
+ return 1
+"""
+ )
+ func = tree.body[0]
+ assert isinstance(func, ast.FunctionDef)
+ func.end_lineno = 0
+
+ def _fake_parse(_source: str, _timeout_s: int) -> ast.AST:
+ return tree
+
+ monkeypatch.setattr(extractor, "_parse_with_limits", _fake_parse)
+ units, blocks = extract_units_from_source(
+ source="def f():\n return 1\n",
+ filepath="x.py",
+ module_name="mod",
+ cfg=NormalizationConfig(),
+ min_loc=1,
+ min_stmt=1,
+ )
+ assert units == []
+ assert blocks == []
+
+
+def test_parse_limits_triggers_timeout(monkeypatch: pytest.MonkeyPatch) -> None:
+ def _fake_signal(_sig: int, handler: Callable[[int, object], None] | None) -> None:
+ if callable(handler):
+ handler(_sig, None)
+ return None
+
+ monkeypatch.setattr(os, "name", "posix")
+ monkeypatch.setattr(signal, "getsignal", lambda *_args, **_kwargs: None)
+ monkeypatch.setattr(signal, "signal", _fake_signal)
+ monkeypatch.setattr(signal, "setitimer", lambda *_args, **_kwargs: None)
+
+ with pytest.raises(ParseError, match="AST parsing timeout"):
+ extractor._parse_with_limits("x = 1", 1)
diff --git a/tests/test_fingerprint.py b/tests/test_fingerprint.py
new file mode 100644
index 0000000..dffb176
--- /dev/null
+++ b/tests/test_fingerprint.py
@@ -0,0 +1,15 @@
+from codeclone.fingerprint import bucket_loc, sha1
+
+
+def test_sha1_stable() -> None:
+ assert sha1("abc") == "a9993e364706816aba3e25717850c26c9cd0d89d"
+
+
+def test_bucket_loc_ranges() -> None:
+ assert bucket_loc(0) == "0-19"
+ assert bucket_loc(19) == "0-19"
+ assert bucket_loc(20) == "20-49"
+ assert bucket_loc(49) == "20-49"
+ assert bucket_loc(50) == "50-99"
+ assert bucket_loc(99) == "50-99"
+ assert bucket_loc(100) == "100+"
diff --git a/tests/test_html_report.py b/tests/test_html_report.py
new file mode 100644
index 0000000..19cde1f
--- /dev/null
+++ b/tests/test_html_report.py
@@ -0,0 +1,216 @@
+import importlib
+from pathlib import Path
+
+import pytest
+
+from codeclone.errors import FileProcessingError
+from codeclone.html_report import (
+ _FileCache,
+ _prefix_css,
+ _pygments_css,
+ _try_pygments,
+ build_html_report,
+)
+
+
+def test_html_report_empty() -> None:
+ html = build_html_report(func_groups={}, block_groups={}, title="Empty Report")
+ assert "" in html
+ assert "Empty Report" in html
+ assert "No code clones detected" in html
+
+
+def test_html_report_generation(tmp_path: Path) -> None:
+ f1 = tmp_path / "a.py"
+ f1.write_text("def f1():\n pass\n", "utf-8")
+ f2 = tmp_path / "b.py"
+ f2.write_text("def f2():\n pass\n", "utf-8")
+
+ func_groups = {
+ "hash1": [
+ {"qualname": "f1", "filepath": str(f1), "start_line": 1, "end_line": 2},
+ {"qualname": "f2", "filepath": str(f2), "start_line": 1, "end_line": 2},
+ ]
+ }
+
+ html = build_html_report(
+ func_groups=func_groups,
+ block_groups={},
+ title="Test Report",
+ context_lines=1,
+ max_snippet_lines=10,
+ )
+
+ assert "Test Report" in html
+ assert "f1" in html
+ assert "f2" in html
+ assert "codebox" in html
+
+
+def test_file_cache_reads_ranges(tmp_path: Path) -> None:
+ f = tmp_path / "sample.py"
+ f.write_text("\n".join([f"line{i}" for i in range(1, 21)]), "utf-8")
+
+ cache = _FileCache(maxsize=4)
+ lines = cache.get_lines_range(str(f), 5, 8)
+
+ assert lines == ("line5", "line6", "line7", "line8")
+ assert cache.cache_info().hits == 0
+ lines2 = cache.get_lines_range(str(f), 5, 8)
+ assert lines2 == lines
+ assert cache.cache_info().hits == 1
+
+
+def test_file_cache_missing_file(tmp_path: Path) -> None:
+ cache = _FileCache(maxsize=2)
+ missing = tmp_path / "missing.py"
+ with pytest.raises(FileProcessingError):
+ cache.get_lines_range(str(missing), 1, 2)
+
+
+def test_file_cache_unicode_fallback(tmp_path: Path) -> None:
+ f = tmp_path / "bad.py"
+ f.write_bytes(b"\xff\xfe\xff\n")
+ cache = _FileCache(maxsize=2)
+ lines = cache.get_lines_range(str(f), 1, 2)
+ assert len(lines) == 1
+
+
+def test_file_cache_range_bounds(tmp_path: Path) -> None:
+ f = tmp_path / "a.py"
+ f.write_text("x = 1\n", "utf-8")
+ cache = _FileCache(maxsize=2)
+ lines = cache.get_lines_range(str(f), 0, 0)
+ assert lines == ()
+ lines2 = cache.get_lines_range(str(f), -3, 1)
+ assert len(lines2) == 1
+
+
+def test_render_code_block_truncate(tmp_path: Path) -> None:
+ f = tmp_path / "a.py"
+ f.write_text("\n".join([f"line{i}" for i in range(1, 50)]), "utf-8")
+ html = build_html_report(
+ func_groups={
+ "h": [
+ {
+ "qualname": "f",
+ "filepath": str(f),
+ "start_line": 1,
+ "end_line": 40,
+ "loc": 40,
+ }
+ ]
+ },
+ block_groups={},
+ title="Truncate",
+ context_lines=10,
+ max_snippet_lines=5,
+ )
+ assert "Truncate" in html
+
+
+def test_prefix_css() -> None:
+ css = "/* c */\n\n.a{color:red}\nplain\n.b { color: blue; }\n"
+ prefixed = _prefix_css(css, ".wrap")
+ assert ".wrap .a" in prefixed
+ assert ".wrap .b" in prefixed
+ assert "/* c */" in prefixed
+
+
+def test_pygments_css() -> None:
+ css = _pygments_css("default")
+ assert ".codebox" in css or css == ""
+
+
+def test_pygments_css_invalid_style() -> None:
+ css = _pygments_css("no-such-style")
+ assert isinstance(css, str)
+
+
+def test_pygments_css_import_error(monkeypatch: pytest.MonkeyPatch) -> None:
+ def _boom(_name: str) -> object:
+ raise ImportError
+
+ monkeypatch.setattr(importlib, "import_module", _boom)
+ assert _pygments_css("default") == ""
+
+
+def test_try_pygments_missing(monkeypatch: pytest.MonkeyPatch) -> None:
+ def _boom(_name: str) -> object:
+ raise ImportError
+
+ monkeypatch.setattr(importlib, "import_module", _boom)
+ assert _try_pygments("x = 1") is None
+
+
+def test_try_pygments_ok() -> None:
+ result = _try_pygments("x = 1")
+ assert result is None or isinstance(result, str)
+
+
+def test_html_report_with_blocks(tmp_path: Path) -> None:
+ f1 = tmp_path / "a.py"
+ f1.write_text("def f1():\n pass\n", "utf-8")
+ f2 = tmp_path / "b.py"
+ f2.write_text("def f2():\n pass\n", "utf-8")
+
+ block_groups = {
+ "h1": [
+ {
+ "qualname": "f1",
+ "filepath": str(f1),
+ "start_line": 1,
+ "end_line": 2,
+ "size": 4,
+ },
+ {
+ "qualname": "f2",
+ "filepath": str(f2),
+ "start_line": 1,
+ "end_line": 2,
+ "size": 4,
+ },
+ ]
+ }
+ html = build_html_report(func_groups={}, block_groups=block_groups, title="Blocks")
+ assert "Block clones" in html
+
+
+def test_html_report_pygments_fallback(monkeypatch: pytest.MonkeyPatch) -> None:
+ import codeclone.html_report as hr
+
+ def _fake_css(name: str) -> str:
+ if name in ("github-dark", "github-light"):
+ return ""
+ return "x"
+
+ monkeypatch.setattr(hr, "_pygments_css", _fake_css)
+ html = build_html_report(func_groups={}, block_groups={}, title="Pygments")
+ assert "Pygments" in html
+
+
+def test_pygments_css_get_style_defs_error(monkeypatch: pytest.MonkeyPatch) -> None:
+ class _Fmt:
+ def __init__(self, *args: object, **kwargs: object) -> None:
+ return None
+
+ def get_style_defs(self, _selector: str) -> str:
+ raise RuntimeError("nope")
+
+ class _Mod:
+ HtmlFormatter = _Fmt
+
+ monkeypatch.setattr(importlib, "import_module", lambda _name: _Mod)
+ assert _pygments_css("default") == ""
+
+
+def test_pygments_css_formatter_init_fails(monkeypatch: pytest.MonkeyPatch) -> None:
+ class _Fmt:
+ def __init__(self, *args: object, **kwargs: object) -> None:
+ raise RuntimeError("nope")
+
+ class _Mod:
+ HtmlFormatter = _Fmt
+
+ monkeypatch.setattr(importlib, "import_module", lambda _name: _Mod)
+ assert _pygments_css("default") == ""
diff --git a/tests/test_init.py b/tests/test_init.py
new file mode 100644
index 0000000..69b6098
--- /dev/null
+++ b/tests/test_init.py
@@ -0,0 +1,26 @@
+from types import ModuleType
+
+import pytest
+
+
+def test_version_fallback(monkeypatch: pytest.MonkeyPatch) -> None:
+ import importlib.metadata
+
+ def _raise(_name: str) -> str:
+ raise importlib.metadata.PackageNotFoundError
+
+ monkeypatch.setattr(importlib.metadata, "version", _raise)
+ module = importlib.reload(importlib.import_module("codeclone"))
+ assert isinstance(module, ModuleType)
+ assert module.__version__ == "dev"
+
+
+def test_version_from_metadata(monkeypatch: pytest.MonkeyPatch) -> None:
+ import importlib.metadata
+
+ def _fake(_name: str) -> str:
+ return "1.2.3"
+
+ monkeypatch.setattr(importlib.metadata, "version", _fake)
+ module = importlib.reload(importlib.import_module("codeclone"))
+ assert module.__version__ == "1.2.3"
diff --git a/tests/test_normalize.py b/tests/test_normalize.py
index 0ba35e2..00cf715 100644
--- a/tests/test_normalize.py
+++ b/tests/test_normalize.py
@@ -3,7 +3,7 @@
from codeclone.normalize import NormalizationConfig, normalized_ast_dump
-def test_normalization_ignores_variable_names():
+def test_normalization_ignores_variable_names() -> None:
src1 = """
def f():
x = 1
@@ -20,3 +20,128 @@ def f():
a2 = ast.parse(src2).body[0]
assert normalized_ast_dump(a1, cfg) == normalized_ast_dump(a2, cfg)
+
+
+def test_normalization_docstring_removed() -> None:
+ src1 = '''
+def f():
+ """doc"""
+ x = 1
+ return x
+'''
+ src2 = """
+def f():
+ x = 1
+ return x
+"""
+ cfg = NormalizationConfig()
+ a1 = ast.parse(src1).body[0]
+ a2 = ast.parse(src2).body[0]
+ assert normalized_ast_dump(a1, cfg) == normalized_ast_dump(a2, cfg)
+
+
+def test_normalization_type_annotations_removed() -> None:
+ src1 = """
+def f(x: int) -> int:
+ return x
+"""
+ src2 = """
+def f(x):
+ return x
+"""
+ cfg = NormalizationConfig()
+ a1 = ast.parse(src1).body[0]
+ a2 = ast.parse(src2).body[0]
+ assert normalized_ast_dump(a1, cfg) == normalized_ast_dump(a2, cfg)
+
+
+def test_normalization_attributes_and_constants() -> None:
+ src1 = """
+def f():
+ obj.attr = 123
+"""
+ src2 = """
+def f():
+ x.y = 999
+"""
+ cfg = NormalizationConfig()
+ a1 = ast.parse(src1).body[0]
+ a2 = ast.parse(src2).body[0]
+ assert normalized_ast_dump(a1, cfg) == normalized_ast_dump(a2, cfg)
+
+
+def test_normalization_augassign_equivalence() -> None:
+ src1 = """
+def f():
+ x += 1
+"""
+ src2 = """
+def f():
+ x = x + 1
+"""
+ cfg = NormalizationConfig()
+ a1 = ast.parse(src1).body[0]
+ a2 = ast.parse(src2).body[0]
+ assert normalized_ast_dump(a1, cfg) == normalized_ast_dump(a2, cfg)
+
+
+def test_normalization_flags_false_preserve_details() -> None:
+ src = """
+def f(x: int, /, y: int, *, z: int, **k: int) -> int:
+ \"\"\"doc\"\"\"
+ obj.my_attr = 123
+ return x
+"""
+ cfg = NormalizationConfig(
+ ignore_docstrings=False,
+ ignore_type_annotations=False,
+ normalize_attributes=False,
+ normalize_constants=False,
+ normalize_names=False,
+ )
+ node = ast.parse(src).body[0]
+ dump = normalized_ast_dump(node, cfg)
+ assert "my_attr" in dump
+ assert "123" in dump
+ assert "doc" in dump
+ assert "id='x'" in dump
+ assert "id='int'" in dump
+
+
+def test_normalization_type_annotations_posonly_kwonly_vararg() -> None:
+ src = """
+def f(a: int, /, b: int, *args: int, c: int, **kwargs: int) -> int:
+ return a
+"""
+ cfg = NormalizationConfig()
+ node = ast.parse(src).body[0]
+ dump = normalized_ast_dump(node, cfg)
+ assert isinstance(dump, str)
+
+
+def test_normalization_names_constants_attributes_disabled() -> None:
+ src = """
+def f():
+ obj.attr = 7
+ return obj.attr
+"""
+ cfg = NormalizationConfig(
+ normalize_names=False,
+ normalize_attributes=False,
+ normalize_constants=False,
+ )
+ node = ast.parse(src).body[0]
+ dump = normalized_ast_dump(node, cfg)
+ assert "attr" in dump
+ assert "7" in dump
+
+
+def test_normalization_async_function() -> None:
+ src = """
+async def af(x):
+ return x
+"""
+ cfg = NormalizationConfig()
+ node = ast.parse(src).body[0]
+ dump = normalized_ast_dump(node, cfg)
+ assert isinstance(dump, str)
diff --git a/tests/test_report.py b/tests/test_report.py
index b1f9c8d..dec2aea 100644
--- a/tests/test_report.py
+++ b/tests/test_report.py
@@ -1,7 +1,13 @@
-from codeclone.report import build_groups, build_block_groups
+from codeclone.report import (
+ build_block_groups,
+ build_groups,
+ to_json,
+ to_json_report,
+ to_text,
+)
-def test_build_function_groups():
+def test_build_function_groups() -> None:
units = [
{"fingerprint": "abc", "loc_bucket": "20-49", "qualname": "a"},
{"fingerprint": "abc", "loc_bucket": "20-49", "qualname": "b"},
@@ -10,10 +16,10 @@ def test_build_function_groups():
groups = build_groups(units)
assert len(groups) == 1
- assert list(groups.values())[0][0]["fingerprint"] == "abc"
+ assert next(iter(groups.values()))[0]["fingerprint"] == "abc"
-def test_block_groups_require_multiple_functions():
+def test_block_groups_require_multiple_functions() -> None:
blocks = [
{"block_hash": "h1", "qualname": "f1"},
{"block_hash": "h1", "qualname": "f1"},
@@ -22,3 +28,40 @@ def test_block_groups_require_multiple_functions():
groups = build_block_groups(blocks)
assert len(groups) == 1
+
+
+def test_report_output_formats() -> None:
+ groups = {
+ "k1": [
+ {
+ "qualname": "f1",
+ "filepath": "a.py",
+ "start_line": 1,
+ "end_line": 2,
+ "loc": 2,
+ }
+ ],
+ "k2": [
+ {
+ "qualname": "f2",
+ "filepath": "b.py",
+ "start_line": 3,
+ "end_line": 4,
+ "loc": 2,
+ },
+ {
+ "qualname": "f3",
+ "filepath": "c.py",
+ "start_line": 5,
+ "end_line": 6,
+ "loc": 2,
+ },
+ ],
+ }
+ json_out = to_json(groups)
+ report_out = to_json_report(groups, groups)
+ text_out = to_text(groups)
+
+ assert "group_count" in json_out
+ assert '"functions"' in report_out
+ assert "Clone group #1" in text_out
diff --git a/tests/test_scanner_extra.py b/tests/test_scanner_extra.py
new file mode 100644
index 0000000..80ec544
--- /dev/null
+++ b/tests/test_scanner_extra.py
@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+import codeclone.scanner as scanner
+from codeclone.errors import ValidationError
+from codeclone.scanner import iter_py_files, module_name_from_path
+
+
+def test_iter_py_files_in_temp(tmp_path: Path) -> None:
+ src = tmp_path / "a.py"
+ src.write_text("def f():\n return 1\n", "utf-8")
+
+ files = list(iter_py_files(str(tmp_path)))
+ assert str(src) in files
+
+
+def test_iter_py_files_excludes(tmp_path: Path) -> None:
+ pkg = tmp_path / "pkg"
+ pkg.mkdir()
+ good = pkg / "good.py"
+ good.write_text("x = 1\n", "utf-8")
+ skip_dir = pkg / "__pycache__"
+ skip_dir.mkdir()
+ skip = skip_dir / "bad.py"
+ skip.write_text("x = 2\n", "utf-8")
+
+ files = list(iter_py_files(str(tmp_path)))
+ assert str(good) in files
+ assert str(skip) not in files
+
+
+def test_module_name_from_path(tmp_path: Path) -> None:
+ pkg = tmp_path / "pkg"
+ pkg.mkdir()
+ init = pkg / "__init__.py"
+ init.write_text("", "utf-8")
+ module = pkg / "mod.py"
+ module.write_text("x = 1\n", "utf-8")
+
+ assert module_name_from_path(str(tmp_path), str(init)) == "pkg"
+ assert module_name_from_path(str(tmp_path), str(module)) == "pkg.mod"
+
+
+def test_iter_py_files_invalid_root(tmp_path: Path) -> None:
+ missing = tmp_path / "missing"
+ with pytest.raises(ValidationError):
+ list(iter_py_files(str(missing)))
+
+
+def test_iter_py_files_not_directory(tmp_path: Path) -> None:
+ file_path = tmp_path / "file.txt"
+ file_path.write_text("x", "utf-8")
+ with pytest.raises(ValidationError):
+ list(iter_py_files(str(file_path)))
+
+
+def test_iter_py_files_max_files(tmp_path: Path) -> None:
+ src = tmp_path / "a.py"
+ src.write_text("x = 1\n", "utf-8")
+ with pytest.raises(ValidationError):
+ list(iter_py_files(str(tmp_path), max_files=0))
+
+
+def test_iter_py_files_symlink_skip(tmp_path: Path) -> None:
+ outside = tmp_path / "outside"
+ outside.mkdir()
+ out_file = outside / "x.py"
+ out_file.write_text("x = 1\n", "utf-8")
+
+ root = tmp_path / "root"
+ root.mkdir()
+ link = root / "link.py"
+ link.symlink_to(out_file)
+
+ files = list(iter_py_files(str(root)))
+ assert str(link) not in files
+
+
+def test_sensitive_prefix_blocked(
+ tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+ sensitive_root = Path.cwd() / "tmp_sensitive_root"
+ sensitive_root.mkdir()
+ sub = sensitive_root / "sub"
+ sub.mkdir()
+
+ monkeypatch.setattr(scanner, "SENSITIVE_DIRS", {str(sensitive_root)})
+
+ with pytest.raises(ValidationError):
+ list(scanner.iter_py_files(str(sub)))
+
+ sub.rmdir()
+ sensitive_root.rmdir()
+
+
+def test_sensitive_root_blocked(
+ tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+ root = Path.cwd() / "tmp_sensitive_root2"
+ root.mkdir()
+ monkeypatch.setattr(scanner, "SENSITIVE_DIRS", {str(root)})
+ with pytest.raises(ValidationError):
+ list(scanner.iter_py_files(str(root)))
+ root.rmdir()
+
+
+def test_sensitive_directory_blocked_via_dotdot(
+ tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+ fake_temp = tmp_path / "fake_tmp"
+ fake_temp.mkdir()
+ monkeypatch.setattr(scanner, "_get_tempdir", lambda: fake_temp.resolve())
+
+ base = tmp_path / "base"
+ sensitive_root = tmp_path / "sensitive"
+ base.mkdir()
+ sensitive_root.mkdir()
+
+ try:
+ monkeypatch.setattr(scanner, "SENSITIVE_DIRS", {str(sensitive_root)})
+
+ # Path traversal via ".." should resolve to sensitive_root and be blocked
+ path_with_dotdot = base / ".." / sensitive_root.name
+ with pytest.raises(ValidationError):
+ list(scanner.iter_py_files(str(path_with_dotdot)))
+ finally:
+ base.rmdir()
+ sensitive_root.rmdir()
+
+
+def test_symlink_to_sensitive_directory_skipped(
+ tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+ fake_temp = tmp_path / "fake_tmp"
+ fake_temp.mkdir()
+ monkeypatch.setattr(scanner, "_get_tempdir", lambda: fake_temp.resolve())
+
+ root = tmp_path / "root"
+ sensitive_root = tmp_path / "sensitive_link_target"
+ root.mkdir()
+ sensitive_root.mkdir()
+ sensitive_file = sensitive_root / "secret.py"
+ sensitive_file.write_text("x = 1\n", "utf-8")
+
+ try:
+ monkeypatch.setattr(scanner, "SENSITIVE_DIRS", {str(sensitive_root)})
+
+ link = root / "sensitive_link"
+ link.symlink_to(sensitive_root, target_is_directory=True)
+
+ files = list(scanner.iter_py_files(str(root)))
+ assert str(sensitive_file) not in files
+ finally:
+ link = root / "sensitive_link"
+ if link.exists():
+ link.unlink()
+ if sensitive_file.exists():
+ sensitive_file.unlink()
+ if sensitive_root.exists():
+ sensitive_root.rmdir()
+ if root.exists():
+ root.rmdir()
diff --git a/tests/test_security.py b/tests/test_security.py
new file mode 100644
index 0000000..a702fe2
--- /dev/null
+++ b/tests/test_security.py
@@ -0,0 +1,44 @@
+import os
+import tempfile
+from unittest.mock import patch
+
+import pytest
+
+from codeclone.cli import MAX_FILE_SIZE, process_file
+from codeclone.errors import ValidationError
+from codeclone.normalize import NormalizationConfig
+from codeclone.scanner import iter_py_files
+
+
+def test_scanner_path_traversal() -> None:
+ """Test that scanner rejects paths outside root or sensitive paths."""
+ with pytest.raises(ValidationError):
+ list(iter_py_files("/etc"))
+
+ with pytest.raises(ValidationError):
+ list(iter_py_files("/etc/passwd"))
+
+
+def test_process_file_size_limit() -> None:
+ """Test that process_file rejects large files."""
+ with tempfile.NamedTemporaryFile(suffix=".py", delete=False) as tmp:
+ tmp.write(b"print('hello')")
+ tmp_path = tmp.name
+
+ try:
+ cfg = NormalizationConfig()
+
+ # Mock os.path.getsize to return huge size
+ with patch("os.path.getsize", return_value=MAX_FILE_SIZE + 1):
+ result = process_file(tmp_path, os.path.dirname(tmp_path), cfg, 0, 0)
+ assert result.success is False
+ assert result.error is not None
+ assert "File too large" in result.error
+
+ # Normal size should pass
+ with patch("os.path.getsize", return_value=10):
+ result = process_file(tmp_path, os.path.dirname(tmp_path), cfg, 0, 0)
+ assert result.success is True
+
+ finally:
+ os.remove(tmp_path)
diff --git a/uv.lock b/uv.lock
index caea671..e92a282 100644
--- a/uv.lock
+++ b/uv.lock
@@ -180,7 +180,7 @@ wheels = [
[[package]]
name = "codeclone"
-version = "1.2.0"
+version = "1.2.1"
source = { editable = "." }
dependencies = [
{ name = "pygments" },
@@ -192,6 +192,8 @@ dev = [
{ name = "build" },
{ name = "mypy" },
{ name = "pytest" },
+ { name = "pytest-cov" },
+ { name = "ruff" },
{ name = "twine" },
]
@@ -201,7 +203,9 @@ requires-dist = [
{ name = "mypy", marker = "extra == 'dev'", specifier = ">=1.19.1" },
{ name = "pygments", specifier = ">=2.19.2" },
{ name = "pytest", marker = "extra == 'dev'", specifier = ">=9.0.0" },
+ { name = "pytest-cov", marker = "extra == 'dev'", specifier = ">=6.1.0" },
{ name = "rich", specifier = ">=14.3.2" },
+ { name = "ruff", marker = "extra == 'dev'", specifier = ">=0.12.0" },
{ name = "twine", marker = "extra == 'dev'", specifier = ">=5.0.0" },
]
provides-extras = ["dev"]
@@ -215,53 +219,157 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
]
+[[package]]
+name = "coverage"
+version = "7.13.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ad/49/349848445b0e53660e258acbcc9b0d014895b6739237920886672240f84b/coverage-7.13.2.tar.gz", hash = "sha256:044c6951ec37146b72a50cc81ef02217d27d4c3640efd2640311393cbbf143d3", size = 826523, upload-time = "2026-01-25T13:00:04.889Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/a4/2d/63e37369c8e81a643afe54f76073b020f7b97ddbe698c5c944b51b0a2bc5/coverage-7.13.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:f4af3b01763909f477ea17c962e2cca8f39b350a4e46e3a30838b2c12e31b81b", size = 218842, upload-time = "2026-01-25T12:57:15.3Z" },
+ { url = "https://files.pythonhosted.org/packages/57/06/86ce882a8d58cbcb3030e298788988e618da35420d16a8c66dac34f138d0/coverage-7.13.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:36393bd2841fa0b59498f75466ee9bdec4f770d3254f031f23e8fd8e140ffdd2", size = 219360, upload-time = "2026-01-25T12:57:17.572Z" },
+ { url = "https://files.pythonhosted.org/packages/cd/84/70b0eb1ee19ca4ef559c559054c59e5b2ae4ec9af61398670189e5d276e9/coverage-7.13.2-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:9cc7573518b7e2186bd229b1a0fe24a807273798832c27032c4510f47ffdb896", size = 246123, upload-time = "2026-01-25T12:57:19.087Z" },
+ { url = "https://files.pythonhosted.org/packages/35/fb/05b9830c2e8275ebc031e0019387cda99113e62bb500ab328bb72578183b/coverage-7.13.2-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:ca9566769b69a5e216a4e176d54b9df88f29d750c5b78dbb899e379b4e14b30c", size = 247930, upload-time = "2026-01-25T12:57:20.929Z" },
+ { url = "https://files.pythonhosted.org/packages/81/aa/3f37858ca2eed4f09b10ca3c6ddc9041be0a475626cd7fd2712f4a2d526f/coverage-7.13.2-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9c9bdea644e94fd66d75a6f7e9a97bb822371e1fe7eadae2cacd50fcbc28e4dc", size = 249804, upload-time = "2026-01-25T12:57:22.904Z" },
+ { url = "https://files.pythonhosted.org/packages/b6/b3/c904f40c56e60a2d9678a5ee8df3d906d297d15fb8bec5756c3b0a67e2df/coverage-7.13.2-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5bd447332ec4f45838c1ad42268ce21ca87c40deb86eabd59888859b66be22a5", size = 246815, upload-time = "2026-01-25T12:57:24.314Z" },
+ { url = "https://files.pythonhosted.org/packages/41/91/ddc1c5394ca7fd086342486440bfdd6b9e9bda512bf774599c7c7a0081e0/coverage-7.13.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:7c79ad5c28a16a1277e1187cf83ea8dafdcc689a784228a7d390f19776db7c31", size = 247843, upload-time = "2026-01-25T12:57:26.544Z" },
+ { url = "https://files.pythonhosted.org/packages/87/d2/cdff8f4cd33697883c224ea8e003e9c77c0f1a837dc41d95a94dd26aad67/coverage-7.13.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:76e06ccacd1fb6ada5d076ed98a8c6f66e2e6acd3df02819e2ee29fd637b76ad", size = 245850, upload-time = "2026-01-25T12:57:28.507Z" },
+ { url = "https://files.pythonhosted.org/packages/f5/42/e837febb7866bf2553ab53dd62ed52f9bb36d60c7e017c55376ad21fbb05/coverage-7.13.2-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:49d49e9a5e9f4dc3d3dac95278a020afa6d6bdd41f63608a76fa05a719d5b66f", size = 246116, upload-time = "2026-01-25T12:57:30.16Z" },
+ { url = "https://files.pythonhosted.org/packages/09/b1/4a3f935d7df154df02ff4f71af8d61298d713a7ba305d050ae475bfbdde2/coverage-7.13.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:ed2bce0e7bfa53f7b0b01c722da289ef6ad4c18ebd52b1f93704c21f116360c8", size = 246720, upload-time = "2026-01-25T12:57:32.165Z" },
+ { url = "https://files.pythonhosted.org/packages/e1/fe/538a6fd44c515f1c5197a3f078094cbaf2ce9f945df5b44e29d95c864bff/coverage-7.13.2-cp310-cp310-win32.whl", hash = "sha256:1574983178b35b9af4db4a9f7328a18a14a0a0ce76ffaa1c1bacb4cc82089a7c", size = 221465, upload-time = "2026-01-25T12:57:33.511Z" },
+ { url = "https://files.pythonhosted.org/packages/5e/09/4b63a024295f326ec1a40ec8def27799300ce8775b1cbf0d33b1790605c4/coverage-7.13.2-cp310-cp310-win_amd64.whl", hash = "sha256:a360a8baeb038928ceb996f5623a4cd508728f8f13e08d4e96ce161702f3dd99", size = 222397, upload-time = "2026-01-25T12:57:34.927Z" },
+ { url = "https://files.pythonhosted.org/packages/6c/01/abca50583a8975bb6e1c59eff67ed8e48bb127c07dad5c28d9e96ccc09ec/coverage-7.13.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:060ebf6f2c51aff5ba38e1f43a2095e087389b1c69d559fde6049a4b0001320e", size = 218971, upload-time = "2026-01-25T12:57:36.953Z" },
+ { url = "https://files.pythonhosted.org/packages/eb/0e/b6489f344d99cd1e5b4d5e1be52dfd3f8a3dc5112aa6c33948da8cabad4e/coverage-7.13.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c1ea8ca9db5e7469cd364552985e15911548ea5b69c48a17291f0cac70484b2e", size = 219473, upload-time = "2026-01-25T12:57:38.934Z" },
+ { url = "https://files.pythonhosted.org/packages/17/11/db2f414915a8e4ec53f60b17956c27f21fb68fcf20f8a455ce7c2ccec638/coverage-7.13.2-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:b780090d15fd58f07cf2011943e25a5f0c1c894384b13a216b6c86c8a8a7c508", size = 249896, upload-time = "2026-01-25T12:57:40.365Z" },
+ { url = "https://files.pythonhosted.org/packages/80/06/0823fe93913663c017e508e8810c998c8ebd3ec2a5a85d2c3754297bdede/coverage-7.13.2-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:88a800258d83acb803c38175b4495d293656d5fac48659c953c18e5f539a274b", size = 251810, upload-time = "2026-01-25T12:57:42.045Z" },
+ { url = "https://files.pythonhosted.org/packages/61/dc/b151c3cc41b28cdf7f0166c5fa1271cbc305a8ec0124cce4b04f74791a18/coverage-7.13.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6326e18e9a553e674d948536a04a80d850a5eeefe2aae2e6d7cf05d54046c01b", size = 253920, upload-time = "2026-01-25T12:57:44.026Z" },
+ { url = "https://files.pythonhosted.org/packages/2d/35/e83de0556e54a4729a2b94ea816f74ce08732e81945024adee46851c2264/coverage-7.13.2-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:59562de3f797979e1ff07c587e2ac36ba60ca59d16c211eceaa579c266c5022f", size = 250025, upload-time = "2026-01-25T12:57:45.624Z" },
+ { url = "https://files.pythonhosted.org/packages/39/67/af2eb9c3926ce3ea0d58a0d2516fcbdacf7a9fc9559fe63076beaf3f2596/coverage-7.13.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:27ba1ed6f66b0e2d61bfa78874dffd4f8c3a12f8e2b5410e515ab345ba7bc9c3", size = 251612, upload-time = "2026-01-25T12:57:47.713Z" },
+ { url = "https://files.pythonhosted.org/packages/26/62/5be2e25f3d6c711d23b71296f8b44c978d4c8b4e5b26871abfc164297502/coverage-7.13.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:8be48da4d47cc68754ce643ea50b3234557cbefe47c2f120495e7bd0a2756f2b", size = 249670, upload-time = "2026-01-25T12:57:49.378Z" },
+ { url = "https://files.pythonhosted.org/packages/b3/51/400d1b09a8344199f9b6a6fc1868005d766b7ea95e7882e494fa862ca69c/coverage-7.13.2-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:2a47a4223d3361b91176aedd9d4e05844ca67d7188456227b6bf5e436630c9a1", size = 249395, upload-time = "2026-01-25T12:57:50.86Z" },
+ { url = "https://files.pythonhosted.org/packages/e0/36/f02234bc6e5230e2f0a63fd125d0a2093c73ef20fdf681c7af62a140e4e7/coverage-7.13.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:c6f141b468740197d6bd38f2b26ade124363228cc3f9858bd9924ab059e00059", size = 250298, upload-time = "2026-01-25T12:57:52.287Z" },
+ { url = "https://files.pythonhosted.org/packages/b0/06/713110d3dd3151b93611c9cbfc65c15b4156b44f927fced49ac0b20b32a4/coverage-7.13.2-cp311-cp311-win32.whl", hash = "sha256:89567798404af067604246e01a49ef907d112edf2b75ef814b1364d5ce267031", size = 221485, upload-time = "2026-01-25T12:57:53.876Z" },
+ { url = "https://files.pythonhosted.org/packages/16/0c/3ae6255fa1ebcb7dec19c9a59e85ef5f34566d1265c70af5b2fc981da834/coverage-7.13.2-cp311-cp311-win_amd64.whl", hash = "sha256:21dd57941804ae2ac7e921771a5e21bbf9aabec317a041d164853ad0a96ce31e", size = 222421, upload-time = "2026-01-25T12:57:55.433Z" },
+ { url = "https://files.pythonhosted.org/packages/b5/37/fabc3179af4d61d89ea47bd04333fec735cd5e8b59baad44fed9fc4170d7/coverage-7.13.2-cp311-cp311-win_arm64.whl", hash = "sha256:10758e0586c134a0bafa28f2d37dd2cdb5e4a90de25c0fc0c77dabbad46eca28", size = 221088, upload-time = "2026-01-25T12:57:57.41Z" },
+ { url = "https://files.pythonhosted.org/packages/46/39/e92a35f7800222d3f7b2cbb7bbc3b65672ae8d501cb31801b2d2bd7acdf1/coverage-7.13.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f106b2af193f965d0d3234f3f83fc35278c7fb935dfbde56ae2da3dd2c03b84d", size = 219142, upload-time = "2026-01-25T12:58:00.448Z" },
+ { url = "https://files.pythonhosted.org/packages/45/7a/8bf9e9309c4c996e65c52a7c5a112707ecdd9fbaf49e10b5a705a402bbb4/coverage-7.13.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:78f45d21dc4d5d6bd29323f0320089ef7eae16e4bef712dff79d184fa7330af3", size = 219503, upload-time = "2026-01-25T12:58:02.451Z" },
+ { url = "https://files.pythonhosted.org/packages/87/93/17661e06b7b37580923f3f12406ac91d78aeed293fb6da0b69cc7957582f/coverage-7.13.2-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:fae91dfecd816444c74531a9c3d6ded17a504767e97aa674d44f638107265b99", size = 251006, upload-time = "2026-01-25T12:58:04.059Z" },
+ { url = "https://files.pythonhosted.org/packages/12/f0/f9e59fb8c310171497f379e25db060abef9fa605e09d63157eebec102676/coverage-7.13.2-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:264657171406c114787b441484de620e03d8f7202f113d62fcd3d9688baa3e6f", size = 253750, upload-time = "2026-01-25T12:58:05.574Z" },
+ { url = "https://files.pythonhosted.org/packages/e5/b1/1935e31add2232663cf7edd8269548b122a7d100047ff93475dbaaae673e/coverage-7.13.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ae47d8dcd3ded0155afbb59c62bd8ab07ea0fd4902e1c40567439e6db9dcaf2f", size = 254862, upload-time = "2026-01-25T12:58:07.647Z" },
+ { url = "https://files.pythonhosted.org/packages/af/59/b5e97071ec13df5f45da2b3391b6cdbec78ba20757bc92580a5b3d5fa53c/coverage-7.13.2-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8a0b33e9fd838220b007ce8f299114d406c1e8edb21336af4c97a26ecfd185aa", size = 251420, upload-time = "2026-01-25T12:58:09.309Z" },
+ { url = "https://files.pythonhosted.org/packages/3f/75/9495932f87469d013dc515fb0ce1aac5fa97766f38f6b1a1deb1ee7b7f3a/coverage-7.13.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:b3becbea7f3ce9a2d4d430f223ec15888e4deb31395840a79e916368d6004cce", size = 252786, upload-time = "2026-01-25T12:58:10.909Z" },
+ { url = "https://files.pythonhosted.org/packages/6a/59/af550721f0eb62f46f7b8cb7e6f1860592189267b1c411a4e3a057caacee/coverage-7.13.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:f819c727a6e6eeb8711e4ce63d78c620f69630a2e9d53bc95ca5379f57b6ba94", size = 250928, upload-time = "2026-01-25T12:58:12.449Z" },
+ { url = "https://files.pythonhosted.org/packages/9b/b1/21b4445709aae500be4ab43bbcfb4e53dc0811c3396dcb11bf9f23fd0226/coverage-7.13.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:4f7b71757a3ab19f7ba286e04c181004c1d61be921795ee8ba6970fd0ec91da5", size = 250496, upload-time = "2026-01-25T12:58:14.047Z" },
+ { url = "https://files.pythonhosted.org/packages/ba/b1/0f5d89dfe0392990e4f3980adbde3eb34885bc1effb2dc369e0bf385e389/coverage-7.13.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b7fc50d2afd2e6b4f6f2f403b70103d280a8e0cb35320cbbe6debcda02a1030b", size = 252373, upload-time = "2026-01-25T12:58:15.976Z" },
+ { url = "https://files.pythonhosted.org/packages/01/c9/0cf1a6a57a9968cc049a6b896693faa523c638a5314b1fc374eb2b2ac904/coverage-7.13.2-cp312-cp312-win32.whl", hash = "sha256:292250282cf9bcf206b543d7608bda17ca6fc151f4cbae949fc7e115112fbd41", size = 221696, upload-time = "2026-01-25T12:58:17.517Z" },
+ { url = "https://files.pythonhosted.org/packages/4d/05/d7540bf983f09d32803911afed135524570f8c47bb394bf6206c1dc3a786/coverage-7.13.2-cp312-cp312-win_amd64.whl", hash = "sha256:eeea10169fac01549a7921d27a3e517194ae254b542102267bef7a93ed38c40e", size = 222504, upload-time = "2026-01-25T12:58:19.115Z" },
+ { url = "https://files.pythonhosted.org/packages/15/8b/1a9f037a736ced0a12aacf6330cdaad5008081142a7070bc58b0f7930cbc/coverage-7.13.2-cp312-cp312-win_arm64.whl", hash = "sha256:2a5b567f0b635b592c917f96b9a9cb3dbd4c320d03f4bf94e9084e494f2e8894", size = 221120, upload-time = "2026-01-25T12:58:21.334Z" },
+ { url = "https://files.pythonhosted.org/packages/a7/f0/3d3eac7568ab6096ff23791a526b0048a1ff3f49d0e236b2af6fb6558e88/coverage-7.13.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ed75de7d1217cf3b99365d110975f83af0528c849ef5180a12fd91b5064df9d6", size = 219168, upload-time = "2026-01-25T12:58:23.376Z" },
+ { url = "https://files.pythonhosted.org/packages/a3/a6/f8b5cfeddbab95fdef4dcd682d82e5dcff7a112ced57a959f89537ee9995/coverage-7.13.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:97e596de8fa9bada4d88fde64a3f4d37f1b6131e4faa32bad7808abc79887ddc", size = 219537, upload-time = "2026-01-25T12:58:24.932Z" },
+ { url = "https://files.pythonhosted.org/packages/7b/e6/8d8e6e0c516c838229d1e41cadcec91745f4b1031d4db17ce0043a0423b4/coverage-7.13.2-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:68c86173562ed4413345410c9480a8d64864ac5e54a5cda236748031e094229f", size = 250528, upload-time = "2026-01-25T12:58:26.567Z" },
+ { url = "https://files.pythonhosted.org/packages/8e/78/befa6640f74092b86961f957f26504c8fba3d7da57cc2ab7407391870495/coverage-7.13.2-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:7be4d613638d678b2b3773b8f687537b284d7074695a43fe2fbbfc0e31ceaed1", size = 253132, upload-time = "2026-01-25T12:58:28.251Z" },
+ { url = "https://files.pythonhosted.org/packages/9d/10/1630db1edd8ce675124a2ee0f7becc603d2bb7b345c2387b4b95c6907094/coverage-7.13.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d7f63ce526a96acd0e16c4af8b50b64334239550402fb1607ce6a584a6d62ce9", size = 254374, upload-time = "2026-01-25T12:58:30.294Z" },
+ { url = "https://files.pythonhosted.org/packages/ed/1d/0d9381647b1e8e6d310ac4140be9c428a0277330991e0c35bdd751e338a4/coverage-7.13.2-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:406821f37f864f968e29ac14c3fccae0fec9fdeba48327f0341decf4daf92d7c", size = 250762, upload-time = "2026-01-25T12:58:32.036Z" },
+ { url = "https://files.pythonhosted.org/packages/43/e4/5636dfc9a7c871ee8776af83ee33b4c26bc508ad6cee1e89b6419a366582/coverage-7.13.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ee68e5a4e3e5443623406b905db447dceddffee0dceb39f4e0cd9ec2a35004b5", size = 252502, upload-time = "2026-01-25T12:58:33.961Z" },
+ { url = "https://files.pythonhosted.org/packages/02/2a/7ff2884d79d420cbb2d12fed6fff727b6d0ef27253140d3cdbbd03187ee0/coverage-7.13.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:2ee0e58cca0c17dd9c6c1cdde02bb705c7b3fbfa5f3b0b5afeda20d4ebff8ef4", size = 250463, upload-time = "2026-01-25T12:58:35.529Z" },
+ { url = "https://files.pythonhosted.org/packages/91/c0/ba51087db645b6c7261570400fc62c89a16278763f36ba618dc8657a187b/coverage-7.13.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:6e5bbb5018bf76a56aabdb64246b5288d5ae1b7d0dd4d0534fe86df2c2992d1c", size = 250288, upload-time = "2026-01-25T12:58:37.226Z" },
+ { url = "https://files.pythonhosted.org/packages/03/07/44e6f428551c4d9faf63ebcefe49b30e5c89d1be96f6a3abd86a52da9d15/coverage-7.13.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a55516c68ef3e08e134e818d5e308ffa6b1337cc8b092b69b24287bf07d38e31", size = 252063, upload-time = "2026-01-25T12:58:38.821Z" },
+ { url = "https://files.pythonhosted.org/packages/c2/67/35b730ad7e1859dd57e834d1bc06080d22d2f87457d53f692fce3f24a5a9/coverage-7.13.2-cp313-cp313-win32.whl", hash = "sha256:5b20211c47a8abf4abc3319d8ce2464864fa9f30c5fcaf958a3eed92f4f1fef8", size = 221716, upload-time = "2026-01-25T12:58:40.484Z" },
+ { url = "https://files.pythonhosted.org/packages/0d/82/e5fcf5a97c72f45fc14829237a6550bf49d0ab882ac90e04b12a69db76b4/coverage-7.13.2-cp313-cp313-win_amd64.whl", hash = "sha256:14f500232e521201cf031549fb1ebdfc0a40f401cf519157f76c397e586c3beb", size = 222522, upload-time = "2026-01-25T12:58:43.247Z" },
+ { url = "https://files.pythonhosted.org/packages/b1/f1/25d7b2f946d239dd2d6644ca2cc060d24f97551e2af13b6c24c722ae5f97/coverage-7.13.2-cp313-cp313-win_arm64.whl", hash = "sha256:9779310cb5a9778a60c899f075a8514c89fa6d10131445c2207fc893e0b14557", size = 221145, upload-time = "2026-01-25T12:58:45Z" },
+ { url = "https://files.pythonhosted.org/packages/9e/f7/080376c029c8f76fadfe43911d0daffa0cbdc9f9418a0eead70c56fb7f4b/coverage-7.13.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:e64fa5a1e41ce5df6b547cbc3d3699381c9e2c2c369c67837e716ed0f549d48e", size = 219861, upload-time = "2026-01-25T12:58:46.586Z" },
+ { url = "https://files.pythonhosted.org/packages/42/11/0b5e315af5ab35f4c4a70e64d3314e4eec25eefc6dec13be3a7d5ffe8ac5/coverage-7.13.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:b01899e82a04085b6561eb233fd688474f57455e8ad35cd82286463ba06332b7", size = 220207, upload-time = "2026-01-25T12:58:48.277Z" },
+ { url = "https://files.pythonhosted.org/packages/b2/0c/0874d0318fb1062117acbef06a09cf8b63f3060c22265adaad24b36306b7/coverage-7.13.2-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:838943bea48be0e2768b0cf7819544cdedc1bbb2f28427eabb6eb8c9eb2285d3", size = 261504, upload-time = "2026-01-25T12:58:49.904Z" },
+ { url = "https://files.pythonhosted.org/packages/83/5e/1cd72c22ecb30751e43a72f40ba50fcef1b7e93e3ea823bd9feda8e51f9a/coverage-7.13.2-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:93d1d25ec2b27e90bcfef7012992d1f5121b51161b8bffcda756a816cf13c2c3", size = 263582, upload-time = "2026-01-25T12:58:51.582Z" },
+ { url = "https://files.pythonhosted.org/packages/9b/da/8acf356707c7a42df4d0657020308e23e5a07397e81492640c186268497c/coverage-7.13.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:93b57142f9621b0d12349c43fc7741fe578e4bc914c1e5a54142856cfc0bf421", size = 266008, upload-time = "2026-01-25T12:58:53.234Z" },
+ { url = "https://files.pythonhosted.org/packages/41/41/ea1730af99960309423c6ea8d6a4f1fa5564b2d97bd1d29dda4b42611f04/coverage-7.13.2-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f06799ae1bdfff7ccb8665d75f8291c69110ba9585253de254688aa8a1ccc6c5", size = 260762, upload-time = "2026-01-25T12:58:55.372Z" },
+ { url = "https://files.pythonhosted.org/packages/22/fa/02884d2080ba71db64fdc127b311db60e01fe6ba797d9c8363725e39f4d5/coverage-7.13.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:7f9405ab4f81d490811b1d91c7a20361135a2df4c170e7f0b747a794da5b7f23", size = 263571, upload-time = "2026-01-25T12:58:57.52Z" },
+ { url = "https://files.pythonhosted.org/packages/d2/6b/4083aaaeba9b3112f55ac57c2ce7001dc4d8fa3fcc228a39f09cc84ede27/coverage-7.13.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:f9ab1d5b86f8fbc97a5b3cd6280a3fd85fef3b028689d8a2c00918f0d82c728c", size = 261200, upload-time = "2026-01-25T12:58:59.255Z" },
+ { url = "https://files.pythonhosted.org/packages/e9/d2/aea92fa36d61955e8c416ede9cf9bf142aa196f3aea214bb67f85235a050/coverage-7.13.2-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:f674f59712d67e841525b99e5e2b595250e39b529c3bda14764e4f625a3fa01f", size = 260095, upload-time = "2026-01-25T12:59:01.066Z" },
+ { url = "https://files.pythonhosted.org/packages/0d/ae/04ffe96a80f107ea21b22b2367175c621da920063260a1c22f9452fd7866/coverage-7.13.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c6cadac7b8ace1ba9144feb1ae3cb787a6065ba6d23ffc59a934b16406c26573", size = 262284, upload-time = "2026-01-25T12:59:02.802Z" },
+ { url = "https://files.pythonhosted.org/packages/1c/7a/6f354dcd7dfc41297791d6fb4e0d618acb55810bde2c1fd14b3939e05c2b/coverage-7.13.2-cp313-cp313t-win32.whl", hash = "sha256:14ae4146465f8e6e6253eba0cccd57423e598a4cb925958b240c805300918343", size = 222389, upload-time = "2026-01-25T12:59:04.563Z" },
+ { url = "https://files.pythonhosted.org/packages/8d/d5/080ad292a4a3d3daf411574be0a1f56d6dee2c4fdf6b005342be9fac807f/coverage-7.13.2-cp313-cp313t-win_amd64.whl", hash = "sha256:9074896edd705a05769e3de0eac0a8388484b503b68863dd06d5e473f874fd47", size = 223450, upload-time = "2026-01-25T12:59:06.677Z" },
+ { url = "https://files.pythonhosted.org/packages/88/96/df576fbacc522e9fb8d1c4b7a7fc62eb734be56e2cba1d88d2eabe08ea3f/coverage-7.13.2-cp313-cp313t-win_arm64.whl", hash = "sha256:69e526e14f3f854eda573d3cf40cffd29a1a91c684743d904c33dbdcd0e0f3e7", size = 221707, upload-time = "2026-01-25T12:59:08.363Z" },
+ { url = "https://files.pythonhosted.org/packages/55/53/1da9e51a0775634b04fcc11eb25c002fc58ee4f92ce2e8512f94ac5fc5bf/coverage-7.13.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:387a825f43d680e7310e6f325b2167dd093bc8ffd933b83e9aa0983cf6e0a2ef", size = 219213, upload-time = "2026-01-25T12:59:11.909Z" },
+ { url = "https://files.pythonhosted.org/packages/46/35/b3caac3ebbd10230fea5a33012b27d19e999a17c9285c4228b4b2e35b7da/coverage-7.13.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:f0d7fea9d8e5d778cd5a9e8fc38308ad688f02040e883cdc13311ef2748cb40f", size = 219549, upload-time = "2026-01-25T12:59:13.638Z" },
+ { url = "https://files.pythonhosted.org/packages/76/9c/e1cf7def1bdc72c1907e60703983a588f9558434a2ff94615747bd73c192/coverage-7.13.2-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:e080afb413be106c95c4ee96b4fffdc9e2fa56a8bbf90b5c0918e5c4449412f5", size = 250586, upload-time = "2026-01-25T12:59:15.808Z" },
+ { url = "https://files.pythonhosted.org/packages/ba/49/f54ec02ed12be66c8d8897270505759e057b0c68564a65c429ccdd1f139e/coverage-7.13.2-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a7fc042ba3c7ce25b8a9f097eb0f32a5ce1ccdb639d9eec114e26def98e1f8a4", size = 253093, upload-time = "2026-01-25T12:59:17.491Z" },
+ { url = "https://files.pythonhosted.org/packages/fb/5e/aaf86be3e181d907e23c0f61fccaeb38de8e6f6b47aed92bf57d8fc9c034/coverage-7.13.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d0ba505e021557f7f8173ee8cd6b926373d8653e5ff7581ae2efce1b11ef4c27", size = 254446, upload-time = "2026-01-25T12:59:19.752Z" },
+ { url = "https://files.pythonhosted.org/packages/28/c8/a5fa01460e2d75b0c853b392080d6829d3ca8b5ab31e158fa0501bc7c708/coverage-7.13.2-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7de326f80e3451bd5cc7239ab46c73ddb658fe0b7649476bc7413572d36cd548", size = 250615, upload-time = "2026-01-25T12:59:21.928Z" },
+ { url = "https://files.pythonhosted.org/packages/86/0b/6d56315a55f7062bb66410732c24879ccb2ec527ab6630246de5fe45a1df/coverage-7.13.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:abaea04f1e7e34841d4a7b343904a3f59481f62f9df39e2cd399d69a187a9660", size = 252452, upload-time = "2026-01-25T12:59:23.592Z" },
+ { url = "https://files.pythonhosted.org/packages/30/19/9bc550363ebc6b0ea121977ee44d05ecd1e8bf79018b8444f1028701c563/coverage-7.13.2-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:9f93959ee0c604bccd8e0697be21de0887b1f73efcc3aa73a3ec0fd13feace92", size = 250418, upload-time = "2026-01-25T12:59:25.392Z" },
+ { url = "https://files.pythonhosted.org/packages/1f/53/580530a31ca2f0cc6f07a8f2ab5460785b02bb11bdf815d4c4d37a4c5169/coverage-7.13.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:13fe81ead04e34e105bf1b3c9f9cdf32ce31736ee5d90a8d2de02b9d3e1bcb82", size = 250231, upload-time = "2026-01-25T12:59:27.888Z" },
+ { url = "https://files.pythonhosted.org/packages/e2/42/dd9093f919dc3088cb472893651884bd675e3df3d38a43f9053656dca9a2/coverage-7.13.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d6d16b0f71120e365741bca2cb473ca6fe38930bc5431c5e850ba949f708f892", size = 251888, upload-time = "2026-01-25T12:59:29.636Z" },
+ { url = "https://files.pythonhosted.org/packages/fa/a6/0af4053e6e819774626e133c3d6f70fae4d44884bfc4b126cb647baee8d3/coverage-7.13.2-cp314-cp314-win32.whl", hash = "sha256:9b2f4714bb7d99ba3790ee095b3b4ac94767e1347fe424278a0b10acb3ff04fe", size = 221968, upload-time = "2026-01-25T12:59:31.424Z" },
+ { url = "https://files.pythonhosted.org/packages/c4/cc/5aff1e1f80d55862442855517bb8ad8ad3a68639441ff6287dde6a58558b/coverage-7.13.2-cp314-cp314-win_amd64.whl", hash = "sha256:e4121a90823a063d717a96e0a0529c727fb31ea889369a0ee3ec00ed99bf6859", size = 222783, upload-time = "2026-01-25T12:59:33.118Z" },
+ { url = "https://files.pythonhosted.org/packages/de/20/09abafb24f84b3292cc658728803416c15b79f9ee5e68d25238a895b07d9/coverage-7.13.2-cp314-cp314-win_arm64.whl", hash = "sha256:6873f0271b4a15a33e7590f338d823f6f66f91ed147a03938d7ce26efd04eee6", size = 221348, upload-time = "2026-01-25T12:59:34.939Z" },
+ { url = "https://files.pythonhosted.org/packages/b6/60/a3820c7232db63be060e4019017cd3426751c2699dab3c62819cdbcea387/coverage-7.13.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:f61d349f5b7cd95c34017f1927ee379bfbe9884300d74e07cf630ccf7a610c1b", size = 219950, upload-time = "2026-01-25T12:59:36.624Z" },
+ { url = "https://files.pythonhosted.org/packages/fd/37/e4ef5975fdeb86b1e56db9a82f41b032e3d93a840ebaf4064f39e770d5c5/coverage-7.13.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a43d34ce714f4ca674c0d90beb760eb05aad906f2c47580ccee9da8fe8bfb417", size = 220209, upload-time = "2026-01-25T12:59:38.339Z" },
+ { url = "https://files.pythonhosted.org/packages/54/df/d40e091d00c51adca1e251d3b60a8b464112efa3004949e96a74d7c19a64/coverage-7.13.2-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bff1b04cb9d4900ce5c56c4942f047dc7efe57e2608cb7c3c8936e9970ccdbee", size = 261576, upload-time = "2026-01-25T12:59:40.446Z" },
+ { url = "https://files.pythonhosted.org/packages/c5/44/5259c4bed54e3392e5c176121af9f71919d96dde853386e7730e705f3520/coverage-7.13.2-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6ae99e4560963ad8e163e819e5d77d413d331fd00566c1e0856aa252303552c1", size = 263704, upload-time = "2026-01-25T12:59:42.346Z" },
+ { url = "https://files.pythonhosted.org/packages/16/bd/ae9f005827abcbe2c70157459ae86053971c9fa14617b63903abbdce26d9/coverage-7.13.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e79a8c7d461820257d9aa43716c4efc55366d7b292e46b5b37165be1d377405d", size = 266109, upload-time = "2026-01-25T12:59:44.073Z" },
+ { url = "https://files.pythonhosted.org/packages/a2/c0/8e279c1c0f5b1eaa3ad9b0fb7a5637fc0379ea7d85a781c0fe0bb3cfc2ab/coverage-7.13.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:060ee84f6a769d40c492711911a76811b4befb6fba50abb450371abb720f5bd6", size = 260686, upload-time = "2026-01-25T12:59:45.804Z" },
+ { url = "https://files.pythonhosted.org/packages/b2/47/3a8112627e9d863e7cddd72894171c929e94491a597811725befdcd76bce/coverage-7.13.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:3bca209d001fd03ea2d978f8a4985093240a355c93078aee3f799852c23f561a", size = 263568, upload-time = "2026-01-25T12:59:47.929Z" },
+ { url = "https://files.pythonhosted.org/packages/92/bc/7ea367d84afa3120afc3ce6de294fd2dcd33b51e2e7fbe4bbfd200f2cb8c/coverage-7.13.2-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:6b8092aa38d72f091db61ef83cb66076f18f02da3e1a75039a4f218629600e04", size = 261174, upload-time = "2026-01-25T12:59:49.717Z" },
+ { url = "https://files.pythonhosted.org/packages/33/b7/f1092dcecb6637e31cc2db099581ee5c61a17647849bae6b8261a2b78430/coverage-7.13.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:4a3158dc2dcce5200d91ec28cd315c999eebff355437d2765840555d765a6e5f", size = 260017, upload-time = "2026-01-25T12:59:51.463Z" },
+ { url = "https://files.pythonhosted.org/packages/2b/cd/f3d07d4b95fbe1a2ef0958c15da614f7e4f557720132de34d2dc3aa7e911/coverage-7.13.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:3973f353b2d70bd9796cc12f532a05945232ccae966456c8ed7034cb96bbfd6f", size = 262337, upload-time = "2026-01-25T12:59:53.407Z" },
+ { url = "https://files.pythonhosted.org/packages/e0/db/b0d5b2873a07cb1e06a55d998697c0a5a540dcefbf353774c99eb3874513/coverage-7.13.2-cp314-cp314t-win32.whl", hash = "sha256:79f6506a678a59d4ded048dc72f1859ebede8ec2b9a2d509ebe161f01c2879d3", size = 222749, upload-time = "2026-01-25T12:59:56.316Z" },
+ { url = "https://files.pythonhosted.org/packages/e5/2f/838a5394c082ac57d85f57f6aba53093b30d9089781df72412126505716f/coverage-7.13.2-cp314-cp314t-win_amd64.whl", hash = "sha256:196bfeabdccc5a020a57d5a368c681e3a6ceb0447d153aeccc1ab4d70a5032ba", size = 223857, upload-time = "2026-01-25T12:59:58.201Z" },
+ { url = "https://files.pythonhosted.org/packages/44/d4/b608243e76ead3a4298824b50922b89ef793e50069ce30316a65c1b4d7ef/coverage-7.13.2-cp314-cp314t-win_arm64.whl", hash = "sha256:69269ab58783e090bfbf5b916ab3d188126e22d6070bbfc93098fdd474ef937c", size = 221881, upload-time = "2026-01-25T13:00:00.449Z" },
+ { url = "https://files.pythonhosted.org/packages/d2/db/d291e30fdf7ea617a335531e72294e0c723356d7fdde8fba00610a76bda9/coverage-7.13.2-py3-none-any.whl", hash = "sha256:40ce1ea1e25125556d8e76bd0b61500839a07944cc287ac21d5626f3e620cad5", size = 210943, upload-time = "2026-01-25T13:00:02.388Z" },
+]
+
+[package.optional-dependencies]
+toml = [
+ { name = "tomli", marker = "python_full_version <= '3.11'" },
+]
+
[[package]]
name = "cryptography"
-version = "46.0.3"
+version = "46.0.4"
source = { registry = "https://pypi.org/simple" }
dependencies = [
{ name = "cffi", marker = "platform_python_implementation != 'PyPy'" },
{ name = "typing-extensions", marker = "python_full_version < '3.11'" },
]
-sdist = { url = "https://files.pythonhosted.org/packages/9f/33/c00162f49c0e2fe8064a62cb92b93e50c74a72bc370ab92f86112b33ff62/cryptography-46.0.3.tar.gz", hash = "sha256:a8b17438104fed022ce745b362294d9ce35b4c2e45c1d958ad4a4b019285f4a1", size = 749258, upload-time = "2025-10-15T23:18:31.74Z" }
-wheels = [
- { url = "https://files.pythonhosted.org/packages/1c/67/38769ca6b65f07461eb200e85fc1639b438bdc667be02cf7f2cd6a64601c/cryptography-46.0.3-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:09859af8466b69bc3c27bdf4f5d84a665e0f7ab5088412e9e2ec49758eca5cbc", size = 4296667, upload-time = "2025-10-15T23:16:54.369Z" },
- { url = "https://files.pythonhosted.org/packages/5c/49/498c86566a1d80e978b42f0d702795f69887005548c041636df6ae1ca64c/cryptography-46.0.3-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:01ca9ff2885f3acc98c29f1860552e37f6d7c7d013d7334ff2a9de43a449315d", size = 4450807, upload-time = "2025-10-15T23:16:56.414Z" },
- { url = "https://files.pythonhosted.org/packages/4b/0a/863a3604112174c8624a2ac3c038662d9e59970c7f926acdcfaed8d61142/cryptography-46.0.3-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:6eae65d4c3d33da080cff9c4ab1f711b15c1d9760809dad6ea763f3812d254cb", size = 4299615, upload-time = "2025-10-15T23:16:58.442Z" },
- { url = "https://files.pythonhosted.org/packages/64/02/b73a533f6b64a69f3cd3872acb6ebc12aef924d8d103133bb3ea750dc703/cryptography-46.0.3-cp311-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e5bf0ed4490068a2e72ac03d786693adeb909981cc596425d09032d372bcc849", size = 4016800, upload-time = "2025-10-15T23:17:00.378Z" },
- { url = "https://files.pythonhosted.org/packages/25/d5/16e41afbfa450cde85a3b7ec599bebefaef16b5c6ba4ec49a3532336ed72/cryptography-46.0.3-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:5ecfccd2329e37e9b7112a888e76d9feca2347f12f37918facbb893d7bb88ee8", size = 4984707, upload-time = "2025-10-15T23:17:01.98Z" },
- { url = "https://files.pythonhosted.org/packages/c9/56/e7e69b427c3878352c2fb9b450bd0e19ed552753491d39d7d0a2f5226d41/cryptography-46.0.3-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:a2c0cd47381a3229c403062f764160d57d4d175e022c1df84e168c6251a22eec", size = 4482541, upload-time = "2025-10-15T23:17:04.078Z" },
- { url = "https://files.pythonhosted.org/packages/78/f6/50736d40d97e8483172f1bb6e698895b92a223dba513b0ca6f06b2365339/cryptography-46.0.3-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:549e234ff32571b1f4076ac269fcce7a808d3bf98b76c8dd560e42dbc66d7d91", size = 4299464, upload-time = "2025-10-15T23:17:05.483Z" },
- { url = "https://files.pythonhosted.org/packages/00/de/d8e26b1a855f19d9994a19c702fa2e93b0456beccbcfe437eda00e0701f2/cryptography-46.0.3-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:c0a7bb1a68a5d3471880e264621346c48665b3bf1c3759d682fc0864c540bd9e", size = 4950838, upload-time = "2025-10-15T23:17:07.425Z" },
- { url = "https://files.pythonhosted.org/packages/8f/29/798fc4ec461a1c9e9f735f2fc58741b0daae30688f41b2497dcbc9ed1355/cryptography-46.0.3-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:10b01676fc208c3e6feeb25a8b83d81767e8059e1fe86e1dc62d10a3018fa926", size = 4481596, upload-time = "2025-10-15T23:17:09.343Z" },
- { url = "https://files.pythonhosted.org/packages/15/8d/03cd48b20a573adfff7652b76271078e3045b9f49387920e7f1f631d125e/cryptography-46.0.3-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0abf1ffd6e57c67e92af68330d05760b7b7efb243aab8377e583284dbab72c71", size = 4426782, upload-time = "2025-10-15T23:17:11.22Z" },
- { url = "https://files.pythonhosted.org/packages/fa/b1/ebacbfe53317d55cf33165bda24c86523497a6881f339f9aae5c2e13e57b/cryptography-46.0.3-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a04bee9ab6a4da801eb9b51f1b708a1b5b5c9eb48c03f74198464c66f0d344ac", size = 4698381, upload-time = "2025-10-15T23:17:12.829Z" },
- { url = "https://files.pythonhosted.org/packages/73/dc/9aa866fbdbb95b02e7f9d086f1fccfeebf8953509b87e3f28fff927ff8a0/cryptography-46.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c8daeb2d2174beb4575b77482320303f3d39b8e81153da4f0fb08eb5fe86a6c5", size = 4288728, upload-time = "2025-10-15T23:17:21.527Z" },
- { url = "https://files.pythonhosted.org/packages/c5/fd/bc1daf8230eaa075184cbbf5f8cd00ba9db4fd32d63fb83da4671b72ed8a/cryptography-46.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:39b6755623145ad5eff1dab323f4eae2a32a77a7abef2c5089a04a3d04366715", size = 4435078, upload-time = "2025-10-15T23:17:23.042Z" },
- { url = "https://files.pythonhosted.org/packages/82/98/d3bd5407ce4c60017f8ff9e63ffee4200ab3e23fe05b765cab805a7db008/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:db391fa7c66df6762ee3f00c95a89e6d428f4d60e7abc8328f4fe155b5ac6e54", size = 4293460, upload-time = "2025-10-15T23:17:24.885Z" },
- { url = "https://files.pythonhosted.org/packages/26/e9/e23e7900983c2b8af7a08098db406cf989d7f09caea7897e347598d4cd5b/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:78a97cf6a8839a48c49271cdcbd5cf37ca2c1d6b7fdd86cc864f302b5e9bf459", size = 3995237, upload-time = "2025-10-15T23:17:26.449Z" },
- { url = "https://files.pythonhosted.org/packages/91/15/af68c509d4a138cfe299d0d7ddb14afba15233223ebd933b4bbdbc7155d3/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:dfb781ff7eaa91a6f7fd41776ec37c5853c795d3b358d4896fdbb5df168af422", size = 4967344, upload-time = "2025-10-15T23:17:28.06Z" },
- { url = "https://files.pythonhosted.org/packages/ca/e3/8643d077c53868b681af077edf6b3cb58288b5423610f21c62aadcbe99f4/cryptography-46.0.3-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:6f61efb26e76c45c4a227835ddeae96d83624fb0d29eb5df5b96e14ed1a0afb7", size = 4466564, upload-time = "2025-10-15T23:17:29.665Z" },
- { url = "https://files.pythonhosted.org/packages/0e/43/c1e8726fa59c236ff477ff2b5dc071e54b21e5a1e51aa2cee1676f1c986f/cryptography-46.0.3-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:23b1a8f26e43f47ceb6d6a43115f33a5a37d57df4ea0ca295b780ae8546e8044", size = 4292415, upload-time = "2025-10-15T23:17:31.686Z" },
- { url = "https://files.pythonhosted.org/packages/42/f9/2f8fefdb1aee8a8e3256a0568cffc4e6d517b256a2fe97a029b3f1b9fe7e/cryptography-46.0.3-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:b419ae593c86b87014b9be7396b385491ad7f320bde96826d0dd174459e54665", size = 4931457, upload-time = "2025-10-15T23:17:33.478Z" },
- { url = "https://files.pythonhosted.org/packages/79/30/9b54127a9a778ccd6d27c3da7563e9f2d341826075ceab89ae3b41bf5be2/cryptography-46.0.3-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:50fc3343ac490c6b08c0cf0d704e881d0d660be923fd3076db3e932007e726e3", size = 4466074, upload-time = "2025-10-15T23:17:35.158Z" },
- { url = "https://files.pythonhosted.org/packages/ac/68/b4f4a10928e26c941b1b6a179143af9f4d27d88fe84a6a3c53592d2e76bf/cryptography-46.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:22d7e97932f511d6b0b04f2bfd818d73dcd5928db509460aaf48384778eb6d20", size = 4420569, upload-time = "2025-10-15T23:17:37.188Z" },
- { url = "https://files.pythonhosted.org/packages/a3/49/3746dab4c0d1979888f125226357d3262a6dd40e114ac29e3d2abdf1ec55/cryptography-46.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d55f3dffadd674514ad19451161118fd010988540cee43d8bc20675e775925de", size = 4681941, upload-time = "2025-10-15T23:17:39.236Z" },
- { url = "https://files.pythonhosted.org/packages/27/32/b68d27471372737054cbd34c84981f9edbc24fe67ca225d389799614e27f/cryptography-46.0.3-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:4b7387121ac7d15e550f5cb4a43aef2559ed759c35df7336c402bb8275ac9683", size = 4294089, upload-time = "2025-10-15T23:17:48.269Z" },
- { url = "https://files.pythonhosted.org/packages/26/42/fa8389d4478368743e24e61eea78846a0006caffaf72ea24a15159215a14/cryptography-46.0.3-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:15ab9b093e8f09daab0f2159bb7e47532596075139dd74365da52ecc9cb46c5d", size = 4440029, upload-time = "2025-10-15T23:17:49.837Z" },
- { url = "https://files.pythonhosted.org/packages/5f/eb/f483db0ec5ac040824f269e93dd2bd8a21ecd1027e77ad7bdf6914f2fd80/cryptography-46.0.3-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:46acf53b40ea38f9c6c229599a4a13f0d46a6c3fa9ef19fc1a124d62e338dfa0", size = 4297222, upload-time = "2025-10-15T23:17:51.357Z" },
- { url = "https://files.pythonhosted.org/packages/fd/cf/da9502c4e1912cb1da3807ea3618a6829bee8207456fbbeebc361ec38ba3/cryptography-46.0.3-cp38-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:10ca84c4668d066a9878890047f03546f3ae0a6b8b39b697457b7757aaf18dbc", size = 4012280, upload-time = "2025-10-15T23:17:52.964Z" },
- { url = "https://files.pythonhosted.org/packages/6b/8f/9adb86b93330e0df8b3dcf03eae67c33ba89958fc2e03862ef1ac2b42465/cryptography-46.0.3-cp38-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:36e627112085bb3b81b19fed209c05ce2a52ee8b15d161b7c643a7d5a88491f3", size = 4978958, upload-time = "2025-10-15T23:17:54.965Z" },
- { url = "https://files.pythonhosted.org/packages/d1/a0/5fa77988289c34bdb9f913f5606ecc9ada1adb5ae870bd0d1054a7021cc4/cryptography-46.0.3-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:1000713389b75c449a6e979ffc7dcc8ac90b437048766cef052d4d30b8220971", size = 4473714, upload-time = "2025-10-15T23:17:56.754Z" },
- { url = "https://files.pythonhosted.org/packages/14/e5/fc82d72a58d41c393697aa18c9abe5ae1214ff6f2a5c18ac470f92777895/cryptography-46.0.3-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:b02cf04496f6576afffef5ddd04a0cb7d49cf6be16a9059d793a30b035f6b6ac", size = 4296970, upload-time = "2025-10-15T23:17:58.588Z" },
- { url = "https://files.pythonhosted.org/packages/78/06/5663ed35438d0b09056973994f1aec467492b33bd31da36e468b01ec1097/cryptography-46.0.3-cp38-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:71e842ec9bc7abf543b47cf86b9a743baa95f4677d22baa4c7d5c69e49e9bc04", size = 4940236, upload-time = "2025-10-15T23:18:00.897Z" },
- { url = "https://files.pythonhosted.org/packages/fc/59/873633f3f2dcd8a053b8dd1d38f783043b5fce589c0f6988bf55ef57e43e/cryptography-46.0.3-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:402b58fc32614f00980b66d6e56a5b4118e6cb362ae8f3fda141ba4689bd4506", size = 4472642, upload-time = "2025-10-15T23:18:02.749Z" },
- { url = "https://files.pythonhosted.org/packages/3d/39/8e71f3930e40f6877737d6f69248cf74d4e34b886a3967d32f919cc50d3b/cryptography-46.0.3-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:ef639cb3372f69ec44915fafcd6698b6cc78fbe0c2ea41be867f6ed612811963", size = 4423126, upload-time = "2025-10-15T23:18:04.85Z" },
- { url = "https://files.pythonhosted.org/packages/cd/c7/f65027c2810e14c3e7268353b1681932b87e5a48e65505d8cc17c99e36ae/cryptography-46.0.3-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:3b51b8ca4f1c6453d8829e1eb7299499ca7f313900dd4d89a24b8b87c0a780d4", size = 4686573, upload-time = "2025-10-15T23:18:06.908Z" },
- { url = "https://files.pythonhosted.org/packages/da/38/f59940ec4ee91e93d3311f7532671a5cef5570eb04a144bf203b58552d11/cryptography-46.0.3-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:191bb60a7be5e6f54e30ba16fdfae78ad3a342a0599eb4193ba88e3f3d6e185b", size = 4243992, upload-time = "2025-10-15T23:18:18.695Z" },
- { url = "https://files.pythonhosted.org/packages/b0/0c/35b3d92ddebfdfda76bb485738306545817253d0a3ded0bfe80ef8e67aa5/cryptography-46.0.3-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:c70cc23f12726be8f8bc72e41d5065d77e4515efae3690326764ea1b07845cfb", size = 4409944, upload-time = "2025-10-15T23:18:20.597Z" },
- { url = "https://files.pythonhosted.org/packages/99/55/181022996c4063fc0e7666a47049a1ca705abb9c8a13830f074edb347495/cryptography-46.0.3-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:9394673a9f4de09e28b5356e7fff97d778f8abad85c9d5ac4a4b7e25a0de7717", size = 4242957, upload-time = "2025-10-15T23:18:22.18Z" },
- { url = "https://files.pythonhosted.org/packages/ba/af/72cd6ef29f9c5f731251acadaeb821559fe25f10852f44a63374c9ca08c1/cryptography-46.0.3-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:94cd0549accc38d1494e1f8de71eca837d0509d0d44bf11d158524b0e12cebf9", size = 4409447, upload-time = "2025-10-15T23:18:24.209Z" },
+sdist = { url = "https://files.pythonhosted.org/packages/78/19/f748958276519adf6a0c1e79e7b8860b4830dda55ccdf29f2719b5fc499c/cryptography-46.0.4.tar.gz", hash = "sha256:bfd019f60f8abc2ed1b9be4ddc21cfef059c841d86d710bb69909a688cbb8f59", size = 749301, upload-time = "2026-01-28T00:24:37.379Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/87/91/874b8910903159043b5c6a123b7e79c4559ddd1896e38967567942635778/cryptography-46.0.4-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5f14fba5bf6f4390d7ff8f086c566454bff0411f6d8aa7af79c88b6f9267aecc", size = 4275871, upload-time = "2026-01-28T00:23:09.439Z" },
+ { url = "https://files.pythonhosted.org/packages/c0/35/690e809be77896111f5b195ede56e4b4ed0435b428c2f2b6d35046fbb5e8/cryptography-46.0.4-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:47bcd19517e6389132f76e2d5303ded6cf3f78903da2158a671be8de024f4cd0", size = 4423124, upload-time = "2026-01-28T00:23:11.529Z" },
+ { url = "https://files.pythonhosted.org/packages/1a/5b/a26407d4f79d61ca4bebaa9213feafdd8806dc69d3d290ce24996d3cfe43/cryptography-46.0.4-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:01df4f50f314fbe7009f54046e908d1754f19d0c6d3070df1e6268c5a4af09fa", size = 4277090, upload-time = "2026-01-28T00:23:13.123Z" },
+ { url = "https://files.pythonhosted.org/packages/0c/d8/4bb7aec442a9049827aa34cee1aa83803e528fa55da9a9d45d01d1bb933e/cryptography-46.0.4-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:5aa3e463596b0087b3da0dbe2b2487e9fc261d25da85754e30e3b40637d61f81", size = 4947652, upload-time = "2026-01-28T00:23:14.554Z" },
+ { url = "https://files.pythonhosted.org/packages/2b/08/f83e2e0814248b844265802d081f2fac2f1cbe6cd258e72ba14ff006823a/cryptography-46.0.4-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:0a9ad24359fee86f131836a9ac3bffc9329e956624a2d379b613f8f8abaf5255", size = 4455157, upload-time = "2026-01-28T00:23:16.443Z" },
+ { url = "https://files.pythonhosted.org/packages/0a/05/19d849cf4096448779d2dcc9bb27d097457dac36f7273ffa875a93b5884c/cryptography-46.0.4-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:dc1272e25ef673efe72f2096e92ae39dea1a1a450dd44918b15351f72c5a168e", size = 3981078, upload-time = "2026-01-28T00:23:17.838Z" },
+ { url = "https://files.pythonhosted.org/packages/e6/89/f7bac81d66ba7cde867a743ea5b37537b32b5c633c473002b26a226f703f/cryptography-46.0.4-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:de0f5f4ec8711ebc555f54735d4c673fc34b65c44283895f1a08c2b49d2fd99c", size = 4276213, upload-time = "2026-01-28T00:23:19.257Z" },
+ { url = "https://files.pythonhosted.org/packages/da/9f/7133e41f24edd827020ad21b068736e792bc68eecf66d93c924ad4719fb3/cryptography-46.0.4-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:eeeb2e33d8dbcccc34d64651f00a98cb41b2dc69cef866771a5717e6734dfa32", size = 4912190, upload-time = "2026-01-28T00:23:21.244Z" },
+ { url = "https://files.pythonhosted.org/packages/a6/f7/6d43cbaddf6f65b24816e4af187d211f0bc536a29961f69faedc48501d8e/cryptography-46.0.4-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:3d425eacbc9aceafd2cb429e42f4e5d5633c6f873f5e567077043ef1b9bbf616", size = 4454641, upload-time = "2026-01-28T00:23:22.866Z" },
+ { url = "https://files.pythonhosted.org/packages/9e/4f/ebd0473ad656a0ac912a16bd07db0f5d85184924e14fc88feecae2492834/cryptography-46.0.4-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:91627ebf691d1ea3976a031b61fb7bac1ccd745afa03602275dda443e11c8de0", size = 4405159, upload-time = "2026-01-28T00:23:25.278Z" },
+ { url = "https://files.pythonhosted.org/packages/d1/f7/7923886f32dc47e27adeff8246e976d77258fd2aa3efdd1754e4e323bf49/cryptography-46.0.4-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:2d08bc22efd73e8854b0b7caff402d735b354862f1145d7be3b9c0f740fef6a0", size = 4666059, upload-time = "2026-01-28T00:23:26.766Z" },
+ { url = "https://files.pythonhosted.org/packages/f8/f5/559c25b77f40b6bf828eabaf988efb8b0e17b573545edb503368ca0a2a03/cryptography-46.0.4-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:078e5f06bd2fa5aea5a324f2a09f914b1484f1d0c2a4d6a8a28c74e72f65f2da", size = 4264508, upload-time = "2026-01-28T00:23:34.264Z" },
+ { url = "https://files.pythonhosted.org/packages/49/a1/551fa162d33074b660dc35c9bc3616fefa21a0e8c1edd27b92559902e408/cryptography-46.0.4-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:dce1e4f068f03008da7fa51cc7abc6ddc5e5de3e3d1550334eaf8393982a5829", size = 4409080, upload-time = "2026-01-28T00:23:35.793Z" },
+ { url = "https://files.pythonhosted.org/packages/b0/6a/4d8d129a755f5d6df1bbee69ea2f35ebfa954fa1847690d1db2e8bca46a5/cryptography-46.0.4-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:2067461c80271f422ee7bdbe79b9b4be54a5162e90345f86a23445a0cf3fd8a2", size = 4270039, upload-time = "2026-01-28T00:23:37.263Z" },
+ { url = "https://files.pythonhosted.org/packages/4c/f5/ed3fcddd0a5e39321e595e144615399e47e7c153a1fb8c4862aec3151ff9/cryptography-46.0.4-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:c92010b58a51196a5f41c3795190203ac52edfd5dc3ff99149b4659eba9d2085", size = 4926748, upload-time = "2026-01-28T00:23:38.884Z" },
+ { url = "https://files.pythonhosted.org/packages/43/ae/9f03d5f0c0c00e85ecb34f06d3b79599f20630e4db91b8a6e56e8f83d410/cryptography-46.0.4-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:829c2b12bbc5428ab02d6b7f7e9bbfd53e33efd6672d21341f2177470171ad8b", size = 4442307, upload-time = "2026-01-28T00:23:40.56Z" },
+ { url = "https://files.pythonhosted.org/packages/8b/22/e0f9f2dae8040695103369cf2283ef9ac8abe4d51f68710bec2afd232609/cryptography-46.0.4-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:62217ba44bf81b30abaeda1488686a04a702a261e26f87db51ff61d9d3510abd", size = 3959253, upload-time = "2026-01-28T00:23:42.827Z" },
+ { url = "https://files.pythonhosted.org/packages/01/5b/6a43fcccc51dae4d101ac7d378a8724d1ba3de628a24e11bf2f4f43cba4d/cryptography-46.0.4-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:9c2da296c8d3415b93e6053f5a728649a87a48ce084a9aaf51d6e46c87c7f2d2", size = 4269372, upload-time = "2026-01-28T00:23:44.655Z" },
+ { url = "https://files.pythonhosted.org/packages/17/b7/0f6b8c1dd0779df2b526e78978ff00462355e31c0a6f6cff8a3e99889c90/cryptography-46.0.4-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:9b34d8ba84454641a6bf4d6762d15847ecbd85c1316c0a7984e6e4e9f748ec2e", size = 4891908, upload-time = "2026-01-28T00:23:46.48Z" },
+ { url = "https://files.pythonhosted.org/packages/83/17/259409b8349aa10535358807a472c6a695cf84f106022268d31cea2b6c97/cryptography-46.0.4-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:df4a817fa7138dd0c96c8c8c20f04b8aaa1fac3bbf610913dcad8ea82e1bfd3f", size = 4441254, upload-time = "2026-01-28T00:23:48.403Z" },
+ { url = "https://files.pythonhosted.org/packages/9c/fe/e4a1b0c989b00cee5ffa0764401767e2d1cf59f45530963b894129fd5dce/cryptography-46.0.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:b1de0ebf7587f28f9190b9cb526e901bf448c9e6a99655d2b07fff60e8212a82", size = 4396520, upload-time = "2026-01-28T00:23:50.26Z" },
+ { url = "https://files.pythonhosted.org/packages/b3/81/ba8fd9657d27076eb40d6a2f941b23429a3c3d2f56f5a921d6b936a27bc9/cryptography-46.0.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:9b4d17bc7bd7cdd98e3af40b441feaea4c68225e2eb2341026c84511ad246c0c", size = 4651479, upload-time = "2026-01-28T00:23:51.674Z" },
+ { url = "https://files.pythonhosted.org/packages/d8/cc/8f3224cbb2a928de7298d6ed4790f5ebc48114e02bdc9559196bfb12435d/cryptography-46.0.4-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8bf75b0259e87fa70bddc0b8b4078b76e7fd512fd9afae6c1193bcf440a4dbef", size = 4275419, upload-time = "2026-01-28T00:23:58.364Z" },
+ { url = "https://files.pythonhosted.org/packages/17/43/4a18faa7a872d00e4264855134ba82d23546c850a70ff209e04ee200e76f/cryptography-46.0.4-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3c268a3490df22270955966ba236d6bc4a8f9b6e4ffddb78aac535f1a5ea471d", size = 4419058, upload-time = "2026-01-28T00:23:59.867Z" },
+ { url = "https://files.pythonhosted.org/packages/ee/64/6651969409821d791ba12346a124f55e1b76f66a819254ae840a965d4b9c/cryptography-46.0.4-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:812815182f6a0c1d49a37893a303b44eaac827d7f0d582cecfc81b6427f22973", size = 4278151, upload-time = "2026-01-28T00:24:01.731Z" },
+ { url = "https://files.pythonhosted.org/packages/20/0b/a7fce65ee08c3c02f7a8310cc090a732344066b990ac63a9dfd0a655d321/cryptography-46.0.4-cp38-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:a90e43e3ef65e6dcf969dfe3bb40cbf5aef0d523dff95bfa24256be172a845f4", size = 4939441, upload-time = "2026-01-28T00:24:03.175Z" },
+ { url = "https://files.pythonhosted.org/packages/db/a7/20c5701e2cd3e1dfd7a19d2290c522a5f435dd30957d431dcb531d0f1413/cryptography-46.0.4-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:a05177ff6296644ef2876fce50518dffb5bcdf903c85250974fc8bc85d54c0af", size = 4451617, upload-time = "2026-01-28T00:24:05.403Z" },
+ { url = "https://files.pythonhosted.org/packages/00/dc/3e16030ea9aa47b63af6524c354933b4fb0e352257c792c4deeb0edae367/cryptography-46.0.4-cp38-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:daa392191f626d50f1b136c9b4cf08af69ca8279d110ea24f5c2700054d2e263", size = 3977774, upload-time = "2026-01-28T00:24:06.851Z" },
+ { url = "https://files.pythonhosted.org/packages/42/c8/ad93f14118252717b465880368721c963975ac4b941b7ef88f3c56bf2897/cryptography-46.0.4-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:e07ea39c5b048e085f15923511d8121e4a9dc45cee4e3b970ca4f0d338f23095", size = 4277008, upload-time = "2026-01-28T00:24:08.926Z" },
+ { url = "https://files.pythonhosted.org/packages/00/cf/89c99698151c00a4631fbfcfcf459d308213ac29e321b0ff44ceeeac82f1/cryptography-46.0.4-cp38-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:d5a45ddc256f492ce42a4e35879c5e5528c09cd9ad12420828c972951d8e016b", size = 4903339, upload-time = "2026-01-28T00:24:12.009Z" },
+ { url = "https://files.pythonhosted.org/packages/03/c3/c90a2cb358de4ac9309b26acf49b2a100957e1ff5cc1e98e6c4996576710/cryptography-46.0.4-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:6bb5157bf6a350e5b28aee23beb2d84ae6f5be390b2f8ee7ea179cda077e1019", size = 4451216, upload-time = "2026-01-28T00:24:13.975Z" },
+ { url = "https://files.pythonhosted.org/packages/96/2c/8d7f4171388a10208671e181ca43cdc0e596d8259ebacbbcfbd16de593da/cryptography-46.0.4-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:dd5aba870a2c40f87a3af043e0dee7d9eb02d4aff88a797b48f2b43eff8c3ab4", size = 4404299, upload-time = "2026-01-28T00:24:16.169Z" },
+ { url = "https://files.pythonhosted.org/packages/e9/23/cbb2036e450980f65c6e0a173b73a56ff3bccd8998965dea5cc9ddd424a5/cryptography-46.0.4-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:93d8291da8d71024379ab2cb0b5c57915300155ad42e07f76bea6ad838d7e59b", size = 4664837, upload-time = "2026-01-28T00:24:17.629Z" },
+ { url = "https://files.pythonhosted.org/packages/27/7a/f8d2d13227a9a1a9fe9c7442b057efecffa41f1e3c51d8622f26b9edbe8f/cryptography-46.0.4-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:c236a44acfb610e70f6b3e1c3ca20ff24459659231ef2f8c48e879e2d32b73da", size = 4216693, upload-time = "2026-01-28T00:24:25.758Z" },
+ { url = "https://files.pythonhosted.org/packages/c5/de/3787054e8f7972658370198753835d9d680f6cd4a39df9f877b57f0dd69c/cryptography-46.0.4-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:8a15fb869670efa8f83cbffbc8753c1abf236883225aed74cd179b720ac9ec80", size = 4382765, upload-time = "2026-01-28T00:24:27.577Z" },
+ { url = "https://files.pythonhosted.org/packages/8a/5f/60e0afb019973ba6a0b322e86b3d61edf487a4f5597618a430a2a15f2d22/cryptography-46.0.4-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:fdc3daab53b212472f1524d070735b2f0c214239df131903bae1d598016fa822", size = 4216066, upload-time = "2026-01-28T00:24:29.056Z" },
+ { url = "https://files.pythonhosted.org/packages/81/8e/bf4a0de294f147fee66f879d9bae6f8e8d61515558e3d12785dd90eca0be/cryptography-46.0.4-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:44cc0675b27cadb71bdbb96099cca1fa051cd11d2ade09e5cd3a2edb929ed947", size = 4382025, upload-time = "2026-01-28T00:24:30.681Z" },
]
[[package]]
@@ -583,11 +691,11 @@ wheels = [
[[package]]
name = "packaging"
-version = "25.0"
+version = "26.0"
source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727, upload-time = "2025-04-19T11:48:59.673Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416, upload-time = "2026-01-21T20:50:39.064Z" }
wheels = [
- { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload-time = "2025-04-19T11:48:57.875Z" },
+ { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" },
]
[[package]]
@@ -610,11 +718,11 @@ wheels = [
[[package]]
name = "pycparser"
-version = "2.23"
+version = "3.0"
source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/fe/cf/d2d3b9f5699fb1e4615c8e32ff220203e43b248e1dfcc6736ad9057731ca/pycparser-2.23.tar.gz", hash = "sha256:78816d4f24add8f10a06d6f05b4d424ad9e96cfebf68a4ddc99c65c0720d00c2", size = 173734, upload-time = "2025-09-09T13:23:47.91Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" }
wheels = [
- { url = "https://files.pythonhosted.org/packages/a0/e3/59cd50310fc9b59512193629e1984c1f95e5c8ae6e5d8c69532ccc65a7fe/pycparser-2.23-py3-none-any.whl", hash = "sha256:e5c6e8d3fbad53479cab09ac03729e0a9faf2bee3db8208a550daf5af81a5934", size = 118140, upload-time = "2025-09-09T13:23:46.651Z" },
+ { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" },
]
[[package]]
@@ -653,6 +761,20 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" },
]
+[[package]]
+name = "pytest-cov"
+version = "7.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "coverage", extra = ["toml"] },
+ { name = "pluggy" },
+ { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5e/f7/c933acc76f5208b3b00089573cf6a2bc26dc80a8aece8f52bb7d6b1855ca/pytest_cov-7.0.0.tar.gz", hash = "sha256:33c97eda2e049a0c5298e91f519302a1334c26ac65c1a483d6206fd458361af1", size = 54328, upload-time = "2025-09-09T10:57:02.113Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/ee/49/1377b49de7d0c1ce41292161ea0f721913fa8722c19fb9c1e3aa0367eecb/pytest_cov-7.0.0-py3-none-any.whl", hash = "sha256:3b8e9558b16cc1479da72058bdecf8073661c7f57f7d3c5f22a1c23507f2d861", size = 22424, upload-time = "2025-09-09T10:57:00.695Z" },
+]
+
[[package]]
name = "pywin32-ctypes"
version = "0.2.3"
@@ -725,6 +847,32 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/ef/45/615f5babd880b4bd7d405cc0dc348234c5ffb6ed1ea33e152ede08b2072d/rich-14.3.2-py3-none-any.whl", hash = "sha256:08e67c3e90884651da3239ea668222d19bea7b589149d8014a21c633420dbb69", size = 309963, upload-time = "2026-02-01T16:20:46.078Z" },
]
+[[package]]
+name = "ruff"
+version = "0.14.14"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2e/06/f71e3a86b2df0dfa2d2f72195941cd09b44f87711cb7fa5193732cb9a5fc/ruff-0.14.14.tar.gz", hash = "sha256:2d0f819c9a90205f3a867dbbd0be083bee9912e170fd7d9704cc8ae45824896b", size = 4515732, upload-time = "2026-01-22T22:30:17.527Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/d2/89/20a12e97bc6b9f9f68343952da08a8099c57237aef953a56b82711d55edd/ruff-0.14.14-py3-none-linux_armv6l.whl", hash = "sha256:7cfe36b56e8489dee8fbc777c61959f60ec0f1f11817e8f2415f429552846aed", size = 10467650, upload-time = "2026-01-22T22:30:08.578Z" },
+ { url = "https://files.pythonhosted.org/packages/a3/b1/c5de3fd2d5a831fcae21beda5e3589c0ba67eec8202e992388e4b17a6040/ruff-0.14.14-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:6006a0082336e7920b9573ef8a7f52eec837add1265cc74e04ea8a4368cd704c", size = 10883245, upload-time = "2026-01-22T22:30:04.155Z" },
+ { url = "https://files.pythonhosted.org/packages/b8/7c/3c1db59a10e7490f8f6f8559d1db8636cbb13dccebf18686f4e3c9d7c772/ruff-0.14.14-py3-none-macosx_11_0_arm64.whl", hash = "sha256:026c1d25996818f0bf498636686199d9bd0d9d6341c9c2c3b62e2a0198b758de", size = 10231273, upload-time = "2026-01-22T22:30:34.642Z" },
+ { url = "https://files.pythonhosted.org/packages/a1/6e/5e0e0d9674be0f8581d1f5e0f0a04761203affce3232c1a1189d0e3b4dad/ruff-0.14.14-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f666445819d31210b71e0a6d1c01e24447a20b85458eea25a25fe8142210ae0e", size = 10585753, upload-time = "2026-01-22T22:30:31.781Z" },
+ { url = "https://files.pythonhosted.org/packages/23/09/754ab09f46ff1884d422dc26d59ba18b4e5d355be147721bb2518aa2a014/ruff-0.14.14-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3c0f18b922c6d2ff9a5e6c3ee16259adc513ca775bcf82c67ebab7cbd9da5bc8", size = 10286052, upload-time = "2026-01-22T22:30:24.827Z" },
+ { url = "https://files.pythonhosted.org/packages/c8/cc/e71f88dd2a12afb5f50733851729d6b571a7c3a35bfdb16c3035132675a0/ruff-0.14.14-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1629e67489c2dea43e8658c3dba659edbfd87361624b4040d1df04c9740ae906", size = 11043637, upload-time = "2026-01-22T22:30:13.239Z" },
+ { url = "https://files.pythonhosted.org/packages/67/b2/397245026352494497dac935d7f00f1468c03a23a0c5db6ad8fc49ca3fb2/ruff-0.14.14-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:27493a2131ea0f899057d49d303e4292b2cae2bb57253c1ed1f256fbcd1da480", size = 12194761, upload-time = "2026-01-22T22:30:22.542Z" },
+ { url = "https://files.pythonhosted.org/packages/5b/06/06ef271459f778323112c51b7587ce85230785cd64e91772034ddb88f200/ruff-0.14.14-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:01ff589aab3f5b539e35db38425da31a57521efd1e4ad1ae08fc34dbe30bd7df", size = 12005701, upload-time = "2026-01-22T22:30:20.499Z" },
+ { url = "https://files.pythonhosted.org/packages/41/d6/99364514541cf811ccc5ac44362f88df66373e9fec1b9d1c4cc830593fe7/ruff-0.14.14-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1cc12d74eef0f29f51775f5b755913eb523546b88e2d733e1d701fe65144e89b", size = 11282455, upload-time = "2026-01-22T22:29:59.679Z" },
+ { url = "https://files.pythonhosted.org/packages/ca/71/37daa46f89475f8582b7762ecd2722492df26421714a33e72ccc9a84d7a5/ruff-0.14.14-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bb8481604b7a9e75eff53772496201690ce2687067e038b3cc31aaf16aa0b974", size = 11215882, upload-time = "2026-01-22T22:29:57.032Z" },
+ { url = "https://files.pythonhosted.org/packages/2c/10/a31f86169ec91c0705e618443ee74ede0bdd94da0a57b28e72db68b2dbac/ruff-0.14.14-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:14649acb1cf7b5d2d283ebd2f58d56b75836ed8c6f329664fa91cdea19e76e66", size = 11180549, upload-time = "2026-01-22T22:30:27.175Z" },
+ { url = "https://files.pythonhosted.org/packages/fd/1e/c723f20536b5163adf79bdd10c5f093414293cdf567eed9bdb7b83940f3f/ruff-0.14.14-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:e8058d2145566510790eab4e2fad186002e288dec5e0d343a92fe7b0bc1b3e13", size = 10543416, upload-time = "2026-01-22T22:30:01.964Z" },
+ { url = "https://files.pythonhosted.org/packages/3e/34/8a84cea7e42c2d94ba5bde1d7a4fae164d6318f13f933d92da6d7c2041ff/ruff-0.14.14-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:e651e977a79e4c758eb807f0481d673a67ffe53cfa92209781dfa3a996cf8412", size = 10285491, upload-time = "2026-01-22T22:30:29.51Z" },
+ { url = "https://files.pythonhosted.org/packages/55/ef/b7c5ea0be82518906c978e365e56a77f8de7678c8bb6651ccfbdc178c29f/ruff-0.14.14-py3-none-musllinux_1_2_i686.whl", hash = "sha256:cc8b22da8d9d6fdd844a68ae937e2a0adf9b16514e9a97cc60355e2d4b219fc3", size = 10733525, upload-time = "2026-01-22T22:30:06.499Z" },
+ { url = "https://files.pythonhosted.org/packages/6a/5b/aaf1dfbcc53a2811f6cc0a1759de24e4b03e02ba8762daabd9b6bd8c59e3/ruff-0.14.14-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:16bc890fb4cc9781bb05beb5ab4cd51be9e7cb376bf1dd3580512b24eb3fda2b", size = 11315626, upload-time = "2026-01-22T22:30:36.848Z" },
+ { url = "https://files.pythonhosted.org/packages/2c/aa/9f89c719c467dfaf8ad799b9bae0df494513fb21d31a6059cb5870e57e74/ruff-0.14.14-py3-none-win32.whl", hash = "sha256:b530c191970b143375b6a68e6f743800b2b786bbcf03a7965b06c4bf04568167", size = 10502442, upload-time = "2026-01-22T22:30:38.93Z" },
+ { url = "https://files.pythonhosted.org/packages/87/44/90fa543014c45560cae1fffc63ea059fb3575ee6e1cb654562197e5d16fb/ruff-0.14.14-py3-none-win_amd64.whl", hash = "sha256:3dde1435e6b6fe5b66506c1dff67a421d0b7f6488d466f651c07f4cab3bf20fd", size = 11630486, upload-time = "2026-01-22T22:30:10.852Z" },
+ { url = "https://files.pythonhosted.org/packages/9e/6a/40fee331a52339926a92e17ae748827270b288a35ef4a15c9c8f2ec54715/ruff-0.14.14-py3-none-win_arm64.whl", hash = "sha256:56e6981a98b13a32236a72a8da421d7839221fa308b223b9283312312e5ac76c", size = 10920448, upload-time = "2026-01-22T22:30:15.417Z" },
+]
+
[[package]]
name = "secretstorage"
version = "3.5.0"