idemcheck 0.1.0__tar.gz

idemcheck-0.1.0/LICENSE

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

idemcheck-0.1.0/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: idemcheck
+Version: 0.1.0
+Summary: Find the HTTP handlers that will double-charge when a client retries.
+Author: mgkvibez
+License: MIT
+Keywords: idempotency,api,retries,payments,fastapi,flask,static-analysis
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Dynamic: license-file
+
+# idemcheck
+
+Find the HTTP handlers that will double-charge when a client retries.
+
+A client retries because the network lied. If your handler writes before it can answer,
+the retry writes again. Idempotency libraries exist for every framework, and nothing tells
+you which of your routes is missing the guard.
+
+```
+$ idemcheck examples/
+idemcheck: 1 finding(s) across 2 mutating route(s) in 1 file(s), worst high
+
+[HIGH] examples/app.py:12 (missing-idempotency)
+  route: POST /charge
+  why:   charge with no idempotency key, dedupe store or unique constraint
+  calls: db.orders.insert_one, db.session.commit
+  fix:   read an Idempotency-Key and store it before the first write, or make the write
+         itself unique so a second delivery cannot land twice
+```
+
+The example file contains two POST handlers: `/charge` writes and is flagged, `/charge-safe`
+reads an `Idempotency-Key` first and is not.
+
+## Install
+
+```bash
+pipx install idemcheck     # once it is on PyPI
+# or straight from the repo:
+pipx install git+https://github.com/mgkvibez/idemcheck
+```
+
+Python 3.9 or newer. No runtime dependencies.
+
+## Usage
+
+```bash
+idemcheck                      # scan the current directory
+idemcheck src/ app.py          # scan specific paths
+idemcheck --json | jq .        # machine-readable
+idemcheck --fail-on medium     # stricter gate, for a payments service
+idemcheck --include-tests      # include tests/ (skipped by default)
+```
+
+Exit codes: `0` nothing at or above the threshold, `1` findings, `2` usage error.
+
+`--fail-on` defaults to `high`, so a `PUT` that writes without a guard reports and exits 0
+until you ask otherwise.
+
+## What it looks for
+
+A handler is a finding when it answers a mutating method **and** calls something that
+writes **and** nothing in it mentions a guard.
+
+| Severity | When |
+|---|---|
+| high | `POST`, or any outbound money/HTTP send, with unguarded writes |
+| medium | `PUT`/`PATCH`/`DELETE` with unguarded writes (they should already be idempotent) |
+
+Writes are recognised by method name: `commit`, `flush`, `insert*`, `update*`, `delete*`,
+`save`, `upsert`, `execute`, `add`, plus money movement like `charge`, `capture`,
+`transfer`, `refund`, and queue sends like `delay` and `enqueue`.
+
+A guard is recognised by any of: `idempotency`, `idempotent`, `idem_key`, `request_id`,
+`dedupe`, `dedup_key`, `nonce`, `client_reference`, `get_or_create`, `update_or_create`,
+`on_conflict`, `unique_together`.
+
+Routes are read from the decorator: `@app.post`, `@router.put`, and the
+`methods=[...]` keyword on `@app.route` and `@app.api_route` (Flask and FastAPI).
+
+## What this deliberately does not do
+
+Static analysis cannot prove a handler is safe, and this tool does not claim to.
+
+- A guard installed by a decorator defined in another module is invisible here.
+- An ORM that commits on your behalf, or a write hidden inside a helper function, is
+  invisible here.
+- Django class-based views, generic routers and dynamically constructed handlers are not
+  detected at all.
+- A handler that mentions `request_id` incidentally is treated as guarded, even when it is
+  not. That is a false negative, and it is the direction this tool errs on purpose: a
+  checker that cries wolf gets uninstalled after one afternoon.
+
+The clean line is exactly what it says: no unguarded write was **recognised**.
+
+## Tests
+
+```bash
+python -m pytest -q      # 19 tests
+bash scripts/verify.sh   # the release gate
+```
+
+## Contributing
+
+Adding a framework means teaching the decorator reader one more name in `analyze.py`, and
+adding a fixture that proves both the flagged and the guarded case. A rule that cannot show
+both is not ready.
+
+## License
+
+MIT.

idemcheck-0.1.0/README.md

@@ -0,0 +1,100 @@
+# idemcheck
+
+Find the HTTP handlers that will double-charge when a client retries.
+
+A client retries because the network lied. If your handler writes before it can answer,
+the retry writes again. Idempotency libraries exist for every framework, and nothing tells
+you which of your routes is missing the guard.
+
+```
+$ idemcheck examples/
+idemcheck: 1 finding(s) across 2 mutating route(s) in 1 file(s), worst high
+
+[HIGH] examples/app.py:12 (missing-idempotency)
+  route: POST /charge
+  why:   charge with no idempotency key, dedupe store or unique constraint
+  calls: db.orders.insert_one, db.session.commit
+  fix:   read an Idempotency-Key and store it before the first write, or make the write
+         itself unique so a second delivery cannot land twice
+```
+
+The example file contains two POST handlers: `/charge` writes and is flagged, `/charge-safe`
+reads an `Idempotency-Key` first and is not.
+
+## Install
+
+```bash
+pipx install idemcheck     # once it is on PyPI
+# or straight from the repo:
+pipx install git+https://github.com/mgkvibez/idemcheck
+```
+
+Python 3.9 or newer. No runtime dependencies.
+
+## Usage
+
+```bash
+idemcheck                      # scan the current directory
+idemcheck src/ app.py          # scan specific paths
+idemcheck --json | jq .        # machine-readable
+idemcheck --fail-on medium     # stricter gate, for a payments service
+idemcheck --include-tests      # include tests/ (skipped by default)
+```
+
+Exit codes: `0` nothing at or above the threshold, `1` findings, `2` usage error.
+
+`--fail-on` defaults to `high`, so a `PUT` that writes without a guard reports and exits 0
+until you ask otherwise.
+
+## What it looks for
+
+A handler is a finding when it answers a mutating method **and** calls something that
+writes **and** nothing in it mentions a guard.
+
+| Severity | When |
+|---|---|
+| high | `POST`, or any outbound money/HTTP send, with unguarded writes |
+| medium | `PUT`/`PATCH`/`DELETE` with unguarded writes (they should already be idempotent) |
+
+Writes are recognised by method name: `commit`, `flush`, `insert*`, `update*`, `delete*`,
+`save`, `upsert`, `execute`, `add`, plus money movement like `charge`, `capture`,
+`transfer`, `refund`, and queue sends like `delay` and `enqueue`.
+
+A guard is recognised by any of: `idempotency`, `idempotent`, `idem_key`, `request_id`,
+`dedupe`, `dedup_key`, `nonce`, `client_reference`, `get_or_create`, `update_or_create`,
+`on_conflict`, `unique_together`.
+
+Routes are read from the decorator: `@app.post`, `@router.put`, and the
+`methods=[...]` keyword on `@app.route` and `@app.api_route` (Flask and FastAPI).
+
+## What this deliberately does not do
+
+Static analysis cannot prove a handler is safe, and this tool does not claim to.
+
+- A guard installed by a decorator defined in another module is invisible here.
+- An ORM that commits on your behalf, or a write hidden inside a helper function, is
+  invisible here.
+- Django class-based views, generic routers and dynamically constructed handlers are not
+  detected at all.
+- A handler that mentions `request_id` incidentally is treated as guarded, even when it is
+  not. That is a false negative, and it is the direction this tool errs on purpose: a
+  checker that cries wolf gets uninstalled after one afternoon.
+
+The clean line is exactly what it says: no unguarded write was **recognised**.
+
+## Tests
+
+```bash
+python -m pytest -q      # 19 tests
+bash scripts/verify.sh   # the release gate
+```
+
+## Contributing
+
+Adding a framework means teaching the decorator reader one more name in `analyze.py`, and
+adding a fixture that proves both the flagged and the guarded case. A rule that cannot show
+both is not ready.
+
+## License
+
+MIT.

idemcheck-0.1.0/idemcheck/__init__.py

@@ -0,0 +1,3 @@
+"""idemcheck: find HTTP handlers that will double-charge on a retry."""
+
+__version__ = "0.1.0"

idemcheck-0.1.0/idemcheck/analyze.py

@@ -0,0 +1,251 @@
+"""Find mutating routes whose writes have no protection against a second delivery.
+
+A client retries because the network lied. If the handler charges, inserts, or sends
+before it can answer, the retry charges twice. Libraries that solve this exist per
+framework; nothing tells you which of your routes is missing the guard.
+
+This is static analysis over the AST, so it can only see what is written down. A guard
+built by a decorator defined in another module, or an ORM method that commits for you,
+is invisible. The README says so instead of implying the tool proves safety.
+"""
+
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Iterable, List, Optional, Sequence, Tuple
+
+MUTATING = ("POST", "PUT", "PATCH", "DELETE")
+
+#: Methods that end in a write, anywhere in the codebase.
+WRITE_METHODS = frozenset({
+    "commit", "flush", "save", "insert", "insert_one", "insert_many", "update",
+    "update_one", "upsert", "delete", "delete_one", "execute", "create", "add",
+    "charge", "capture", "transfer", "refund", "enqueue", "delay", "send_message",
+})
+
+#: Outbound calls that move money or send something a retry would duplicate.
+OUTBOUND = ("requests.post", "requests.put", "httpx.post", "httpx.put", "aiohttp.",
+            "stripe.", "session.post", "client.post", "urlopen")
+
+#: Any of these in the handler means somebody thought about the retry.
+PROTECTION = ("idempotency", "idempotent", "idem_key", "idemkey", "request_id",
+              "requestid", "dedupe", "dedup_key", "nonce", "client_reference",
+              "get_or_create", "update_or_create", "on_conflict", "unique_together")
+
+ROUTE_DECORATORS = frozenset({"post", "put", "patch", "delete", "route", "api_route"})
+
+
+@dataclass(frozen=True)
+class Route:
+    """A handler and the mutating methods it answers."""
+
+    line: int
+    methods: Tuple[str, ...]
+    name: str
+
+
+@dataclass
+class Finding:
+    path: str
+    line: int
+    rule: str
+    severity: str
+    route: str
+    detail: str
+    writes: List[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict:
+        return {"path": self.path, "line": self.line, "rule": self.rule,
+                "severity": self.severity, "route": self.route,
+                "detail": self.detail, "writes": self.writes}
+
+
+@dataclass
+class Report:
+    files: int = 0
+    routes: int = 0
+    findings: List[Finding] = field(default_factory=list)
+
+
+def _dotted(node: ast.AST) -> str:
+    """The dotted name of a call target, or '' when it is not a plain name."""
+    parts = []
+    while isinstance(node, ast.Attribute):
+        parts.append(node.attr)
+        node = node.value
+    if isinstance(node, ast.Name):
+        parts.append(node.id)
+    return ".".join(reversed(parts))
+
+
+def _methods_from_decorator(node: ast.AST) -> Optional[Tuple[str, ...]]:
+    """Return the mutating methods a decorator registers, or None if it is not a route."""
+    if not isinstance(node, ast.Call):
+        return None
+    target = _dotted(node.func).rsplit(".", 1)[-1]
+    if target not in ROUTE_DECORATORS:
+        return None
+    if target in ("route", "api_route"):
+        for kw in node.keywords:
+            if kw.arg == "methods" and isinstance(kw.value, (ast.List, ast.Tuple)):
+                names = [e.value.upper() for e in kw.value.elts
+                         if isinstance(e, ast.Constant) and isinstance(e.value, str)]
+                picked = tuple(m for m in names if m in MUTATING)
+                return picked or None
+        return None
+    method = target.upper()
+    return (method,) if method in MUTATING else None
+
+
+def _strings_and_names(func: ast.AST) -> str:
+    """Every identifier and string literal in the handler, lowercased, for guard hunting."""
+    chunks: List[str] = []
+    for node in ast.walk(func):
+        if isinstance(node, ast.Name):
+            chunks.append(node.id)
+        elif isinstance(node, ast.Attribute):
+            chunks.append(node.attr)
+        elif isinstance(node, ast.Constant) and isinstance(node.value, str):
+            chunks.append(node.value)
+        elif isinstance(node, ast.keyword) and node.arg:
+            chunks.append(node.arg)
+    return " ".join(chunks).lower()
+
+
+def _writes(func: ast.AST) -> List[str]:
+    """Dotted names of calls that look like writes or outbound sends."""
+    found: List[str] = []
+    for node in ast.walk(func):
+        if not isinstance(node, ast.Call):
+            continue
+        name = _dotted(node.func)
+        short = name.rsplit(".", 1)[-1]
+        low = name.lower()
+        if short in WRITE_METHODS:
+            found.append(name or short)
+        elif any(marker in low for marker in OUTBOUND):
+            found.append(name or low)
+        elif short == "execute" and any(
+            kw in low for kw in ("insert", "update", "delete")
+        ):
+            found.append(name)
+    # dedupe, keep first-seen order
+    seen: List[str] = []
+    for name in found:
+        if name not in seen:
+            seen.append(name)
+    return seen
+
+
+def _docstring_node(func: ast.AST) -> Optional[ast.AST]:
+    body = getattr(func, "body", [])
+    if body and isinstance(body[0], ast.Expr) and isinstance(body[0].value, ast.Constant) \
+            and isinstance(body[0].value.value, str):
+        return body[0]
+    return None
+
+
+def _has_guard(func: ast.AST) -> bool:
+    """Is there any sign that a second delivery was considered?
+
+    The handler's own docstring is excluded: a docstring that says "TODO: idempotency"
+    is evidence of the bug, not of the fix.
+    """
+    doc = _docstring_node(func)
+    doc_text = doc.value if isinstance(doc, ast.Expr) else None
+    skip = {id(doc), id(doc_text)}
+    chunks: List[str] = []
+    for node in ast.walk(func):
+        if id(node) in skip:
+            continue
+        if isinstance(node, ast.Name):
+            chunks.append(node.id)
+        elif isinstance(node, ast.Attribute):
+            chunks.append(node.attr)
+        elif isinstance(node, ast.Constant) and isinstance(node.value, str):
+            chunks.append(node.value)
+        elif isinstance(node, ast.keyword) and node.arg:
+            chunks.append(node.arg)
+    text = " ".join(chunks).lower()
+    return any(token in text for token in PROTECTION)
+
+
+def _route_path(dec: ast.AST) -> str:
+    if isinstance(dec, ast.Call) and dec.args:
+        first = dec.args[0]
+        if isinstance(first, ast.Constant) and isinstance(first.value, str):
+            return first.value
+    return ""
+
+
+def analyze_source(source: str, path: str = "<src>") -> Tuple[int, List[Finding]]:
+    """Return (mutating routes seen, findings) for one source file."""
+    try:
+        tree = ast.parse(source)
+    except SyntaxError:
+        return 0, []
+    routes = 0
+    findings: List[Finding] = []
+    for node in ast.walk(tree):
+        if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            continue
+        methods: List[str] = []
+        label = ""
+        for dec in node.decorator_list:
+            picked = _methods_from_decorator(dec)
+            if picked:
+                methods.extend(picked)
+                label = label or _route_path(dec)
+        if not methods:
+            continue
+        routes += 1
+        writes = _writes(node)
+        if not writes or _has_guard(node):
+            continue
+        outbound = any(any(m in w.lower() for m in OUTBOUND) for w in writes)
+        severity = "high" if (outbound or "POST" in methods) else "medium"
+        route = "%s %s" % ("|".join(sorted(set(methods))), label or node.name)
+        findings.append(Finding(
+            path=path, line=node.lineno, rule="missing-idempotency", severity=severity,
+            route=route,
+            detail="%s with no idempotency key, dedupe store or unique constraint"
+                   % node.name,
+            writes=writes,
+        ))
+    return routes, findings
+
+
+def _looks_like_tests(path: Path) -> bool:
+    parts = set(path.parts)
+    return "tests" in parts or path.name.startswith("test_") or path.name == "conftest.py"
+
+
+def analyze_files(paths: Iterable[Path], include_tests: bool = False) -> Report:
+    report = Report()
+    seen: set = set()
+    for base in paths:
+        files: Sequence[Path]
+        if base.is_dir():
+            files = sorted(p for p in base.rglob("*.py")
+                           if not any(skip in p.parts for skip in
+                                      (".git", "build", "dist", "node_modules", "__pycache__")))
+        else:
+            files = [base]
+        for path in files:
+            key = str(path.resolve())
+            if key in seen or (not include_tests and _looks_like_tests(path)):
+                continue
+            seen.add(key)
+            try:
+                source = path.read_text(encoding="utf-8", errors="replace")
+            except OSError:
+                continue
+            routes, findings = analyze_source(source, str(path))
+            report.files += 1
+            report.routes += routes
+            report.findings.extend(findings)
+    report.findings.sort(key=lambda f: ({"high": 0, "medium": 1, "low": 2}[f.severity],
+                                        f.path, f.line))
+    return report

idemcheck-0.1.0/idemcheck/cli.py

@@ -0,0 +1,88 @@
+"""The command line: read paths, print findings, and answer with an exit code."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import List, Optional, Sequence
+
+from . import __version__
+from .analyze import analyze_files
+
+EXIT_OK = 0
+EXIT_FINDINGS = 1
+EXIT_USAGE = 2
+
+SEVERITIES = ("high", "medium", "low")
+SEVERITY_RANK = {name: index for index, name in enumerate(SEVERITIES)}
+
+FIX_HINT = (
+    "read an Idempotency-Key and store it before the first write, or make the write\n"
+    "         itself unique so a second delivery cannot land twice"
+)
+
+
+def render(findings: List[dict], files: int, routes: int) -> str:
+    if not findings:
+        return ("No issues found by idemcheck v%s across %d mutating route(s) in %d file(s).\n"
+                "That means no unguarded write was recognised, not that every handler is safe."
+                % (__version__, routes, files))
+
+    worst = min((f["severity"] for f in findings), key=lambda s: SEVERITY_RANK[s])
+    lines = ["idemcheck: %d finding(s) across %d mutating route(s) in %d file(s), worst %s"
+             % (len(findings), routes, files, worst), ""]
+    for f in findings:
+        lines.append("[%s] %s:%d (%s)" % (f["severity"].upper(), f["path"], f["line"], f["rule"]))
+        lines.append("  route: %s" % f["route"])
+        lines.append("  why:   %s" % f["detail"])
+        if f["writes"]:
+            lines.append("  calls: %s" % ", ".join(f["writes"]))
+        lines.append("  fix:   %s" % FIX_HINT)
+        lines.append("")
+    return "\n".join(lines).rstrip()
+
+
+def main(argv: Optional[Sequence[str]] = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="idemcheck",
+        description="Find the HTTP handlers that will double-charge when a client retries.",
+    )
+    parser.add_argument("paths", nargs="*", default=["."],
+                        help="files or directories to scan (default: .)")
+    parser.add_argument("--json", action="store_true", help="machine-readable output")
+    parser.add_argument("--fail-on", choices=("high", "medium", "low", "none"), default="high",
+                        help="lowest severity that fails the run (default: high)")
+    parser.add_argument("--include-tests", action="store_true",
+                        help="also scan tests/ and test_*.py")
+    parser.add_argument("--version", action="version", version="idemcheck %s" % __version__)
+    args = parser.parse_args(argv)
+
+    targets = [Path(p) for p in args.paths]
+    missing = [str(p) for p in targets if not p.exists()]
+    if missing:
+        print("no such path: %s" % ", ".join(missing), file=sys.stderr)
+        return EXIT_USAGE
+
+    report = analyze_files(targets, include_tests=args.include_tests)
+    findings = [f.to_dict() for f in report.findings]
+
+    if args.json:
+        print(json.dumps({
+            "findings": findings,
+            "summary": {"files": report.files, "routes": report.routes,
+                        "findings": len(findings), "fail_on": args.fail_on},
+        }, indent=2))
+    else:
+        print(render(findings, report.files, report.routes))
+
+    if args.fail_on == "none" or not findings:
+        return EXIT_OK
+    limit = SEVERITY_RANK[args.fail_on]
+    return EXIT_FINDINGS if any(SEVERITY_RANK[f["severity"]] <= limit for f in findings) \
+        else EXIT_OK
+
+
+if __name__ == "__main__":        # so `python -m idemcheck.cli` works too
+    raise SystemExit(main())

idemcheck-0.1.0/idemcheck.egg-info/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: idemcheck
+Version: 0.1.0
+Summary: Find the HTTP handlers that will double-charge when a client retries.
+Author: mgkvibez
+License: MIT
+Keywords: idempotency,api,retries,payments,fastapi,flask,static-analysis
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Dynamic: license-file
+
+# idemcheck
+
+Find the HTTP handlers that will double-charge when a client retries.
+
+A client retries because the network lied. If your handler writes before it can answer,
+the retry writes again. Idempotency libraries exist for every framework, and nothing tells
+you which of your routes is missing the guard.
+
+```
+$ idemcheck examples/
+idemcheck: 1 finding(s) across 2 mutating route(s) in 1 file(s), worst high
+
+[HIGH] examples/app.py:12 (missing-idempotency)
+  route: POST /charge
+  why:   charge with no idempotency key, dedupe store or unique constraint
+  calls: db.orders.insert_one, db.session.commit
+  fix:   read an Idempotency-Key and store it before the first write, or make the write
+         itself unique so a second delivery cannot land twice
+```
+
+The example file contains two POST handlers: `/charge` writes and is flagged, `/charge-safe`
+reads an `Idempotency-Key` first and is not.
+
+## Install
+
+```bash
+pipx install idemcheck     # once it is on PyPI
+# or straight from the repo:
+pipx install git+https://github.com/mgkvibez/idemcheck
+```
+
+Python 3.9 or newer. No runtime dependencies.
+
+## Usage
+
+```bash
+idemcheck                      # scan the current directory
+idemcheck src/ app.py          # scan specific paths
+idemcheck --json | jq .        # machine-readable
+idemcheck --fail-on medium     # stricter gate, for a payments service
+idemcheck --include-tests      # include tests/ (skipped by default)
+```
+
+Exit codes: `0` nothing at or above the threshold, `1` findings, `2` usage error.
+
+`--fail-on` defaults to `high`, so a `PUT` that writes without a guard reports and exits 0
+until you ask otherwise.
+
+## What it looks for
+
+A handler is a finding when it answers a mutating method **and** calls something that
+writes **and** nothing in it mentions a guard.
+
+| Severity | When |
+|---|---|
+| high | `POST`, or any outbound money/HTTP send, with unguarded writes |
+| medium | `PUT`/`PATCH`/`DELETE` with unguarded writes (they should already be idempotent) |
+
+Writes are recognised by method name: `commit`, `flush`, `insert*`, `update*`, `delete*`,
+`save`, `upsert`, `execute`, `add`, plus money movement like `charge`, `capture`,
+`transfer`, `refund`, and queue sends like `delay` and `enqueue`.
+
+A guard is recognised by any of: `idempotency`, `idempotent`, `idem_key`, `request_id`,
+`dedupe`, `dedup_key`, `nonce`, `client_reference`, `get_or_create`, `update_or_create`,
+`on_conflict`, `unique_together`.
+
+Routes are read from the decorator: `@app.post`, `@router.put`, and the
+`methods=[...]` keyword on `@app.route` and `@app.api_route` (Flask and FastAPI).
+
+## What this deliberately does not do
+
+Static analysis cannot prove a handler is safe, and this tool does not claim to.
+
+- A guard installed by a decorator defined in another module is invisible here.
+- An ORM that commits on your behalf, or a write hidden inside a helper function, is
+  invisible here.
+- Django class-based views, generic routers and dynamically constructed handlers are not
+  detected at all.
+- A handler that mentions `request_id` incidentally is treated as guarded, even when it is
+  not. That is a false negative, and it is the direction this tool errs on purpose: a
+  checker that cries wolf gets uninstalled after one afternoon.
+
+The clean line is exactly what it says: no unguarded write was **recognised**.
+
+## Tests
+
+```bash
+python -m pytest -q      # 19 tests
+bash scripts/verify.sh   # the release gate
+```
+
+## Contributing
+
+Adding a framework means teaching the decorator reader one more name in `analyze.py`, and
+adding a fixture that proves both the flagged and the guarded case. A rule that cannot show
+both is not ready.
+
+## License
+
+MIT.

idemcheck-0.1.0/idemcheck.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+idemcheck/__init__.py
+idemcheck/analyze.py
+idemcheck/cli.py
+idemcheck.egg-info/PKG-INFO
+idemcheck.egg-info/SOURCES.txt
+idemcheck.egg-info/dependency_links.txt
+idemcheck.egg-info/entry_points.txt
+idemcheck.egg-info/requires.txt
+idemcheck.egg-info/top_level.txt
+tests/test_idemcheck.py

idemcheck-0.1.0/idemcheck.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

idemcheck-0.1.0/idemcheck.egg-info/entry_points.txt

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

idemcheck-0.1.0/idemcheck.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[dev]
+pytest>=8

idemcheck-0.1.0/idemcheck.egg-info/top_level.txt

@@ -0,0 +1 @@
+idemcheck

idemcheck-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "idemcheck"
+version = "0.1.0"
+description = "Find the HTTP handlers that will double-charge when a client retries."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "mgkvibez" }]
+keywords = ["idempotency", "api", "retries", "payments", "fastapi", "flask", "static-analysis"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Topic :: Software Development :: Quality Assurance",
+]
+dependencies = []
+
+[project.optional-dependencies]
+dev = ["pytest>=8"]
+
+[project.scripts]
+idemcheck = "idemcheck.cli:main"
+
+[tool.setuptools]
+packages = ["idemcheck"]
+
+[tool.ruff]
+target-version = "py39"
+line-length = 100
+[tool.ruff.lint]
+select = ["E", "F", "W", "I"]

idemcheck-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

idemcheck-0.1.0/tests/test_idemcheck.py

@@ -0,0 +1,180 @@
+"""The analyser and the CLI contract."""
+
+import json
+
+import pytest
+
+from idemcheck.analyze import analyze_files, analyze_source
+from idemcheck.cli import EXIT_FINDINGS, EXIT_OK, EXIT_USAGE, main
+
+CHARGE = '''
+@app.post("/charge")
+def charge():
+    db.session.add(order)
+    db.session.commit()
+'''
+
+
+def test_a_post_that_writes_with_no_guard_is_high():
+    routes, findings = analyze_source(CHARGE)
+    assert routes == 1
+    assert [f.severity for f in findings] == ["high"]
+    assert findings[0].rule == "missing-idempotency"
+    assert "db.session.commit" in findings[0].writes
+
+
+def test_a_guard_anywhere_in_the_handler_clears_it():
+    src = '''
+@app.post("/charge")
+def charge():
+    key = request.headers.get("Idempotency-Key")
+    db.session.commit()
+'''
+    assert analyze_source(src)[1] == []
+
+
+def test_a_docstring_saying_todo_idempotency_is_the_bug_not_the_fix():
+    """The first cut skipped the docstring node but not its string constant."""
+    src = '''
+@app.post("/charge")
+def charge():
+    """Charge the card. TODO: idempotency."""
+    db.session.commit()
+'''
+    findings = analyze_source(src)[1]
+    assert [f.severity for f in findings] == ["high"]
+
+
+def test_put_and_patch_are_medium_because_they_should_already_be_idempotent():
+    src = '''
+@app.put("/order")
+def update_order():
+    db.session.commit()
+'''
+    findings = analyze_source(src)[1]
+    assert [f.severity for f in findings] == ["medium"]
+
+
+def test_a_read_only_route_is_not_a_finding():
+    src = '''
+@app.get("/orders")
+def orders():
+    return db.orders.find({})
+'''
+    routes, findings = analyze_source(src)
+    assert routes == 0          # GET is not a mutating route
+    assert findings == []
+
+
+def test_a_mutating_route_that_only_reads_is_not_a_finding():
+    src = '''
+@app.post("/preview")
+def preview():
+    return db.orders.find_one({"id": 1})
+'''
+    routes, findings = analyze_source(src)
+    assert routes == 1
+    assert findings == []
+
+
+def test_api_route_methods_keyword_is_understood():
+    src = '''
+@app.api_route("/charge", methods=["POST", "GET"])
+def charge():
+    db.session.commit()
+'''
+    findings = analyze_source(src)[1]
+    assert len(findings) == 1 and findings[0].severity == "high"
+
+
+def test_flask_route_methods_keyword_is_understood():
+    src = '''
+@app.route("/charge", methods=["POST"])
+def charge():
+    db.session.commit()
+'''
+    assert len(analyze_source(src)[1]) == 1
+
+
+def test_flask_route_defaulting_to_get_is_not_a_finding():
+    src = '''
+@app.route("/health")
+def health():
+    db.session.commit()
+'''
+    assert analyze_source(src)[1] == []
+
+
+def test_one_finding_per_handler_however_many_writes():
+    src = '''
+@app.post("/checkout")
+def checkout():
+    db.session.add(a)
+    db.session.commit()
+    payments.charge_card(a)
+    queue.delay(a)
+'''
+    findings = analyze_source(src)[1]
+    assert len(findings) == 1
+    assert len(findings[0].writes) >= 3
+
+
+def test_a_syntax_error_file_is_skipped_not_fatal():
+    assert analyze_source("def broken(:\n") == (0, [])
+
+
+def test_tests_are_excluded_by_default(tmp_path):
+    (tmp_path / "tests").mkdir()
+    (tmp_path / "tests" / "test_api.py").write_text(CHARGE)
+    (tmp_path / "app.py").write_text(CHARGE)
+
+    assert analyze_files([tmp_path]).files == 1
+    assert len(analyze_files([tmp_path]).findings) == 1
+    assert analyze_files([tmp_path], include_tests=True).files == 2
+
+
+# --- CLI contract -------------------------------------------------------------
+
+
+def test_cli_exits_1_on_a_high_finding(tmp_path, capsys):
+    (tmp_path / "app.py").write_text(CHARGE)
+    assert main([str(tmp_path)]) == EXIT_FINDINGS
+    assert "missing-idempotency" in capsys.readouterr().out
+
+
+def test_cli_exits_0_when_nothing_is_unguarded(tmp_path, capsys):
+    (tmp_path / "app.py").write_text('@app.get("/x")\ndef x():\n    return 1\n')
+    assert main([str(tmp_path)]) == EXIT_OK
+    out = capsys.readouterr().out
+    assert "No issues found by idemcheck v" in out
+
+
+def test_fail_on_none_never_fails_the_run(tmp_path):
+    (tmp_path / "app.py").write_text(CHARGE)
+    assert main([str(tmp_path), "--fail-on", "none"]) == EXIT_OK
+
+
+def test_a_medium_finding_does_not_fail_the_default_threshold(tmp_path):
+    (tmp_path / "app.py").write_text('@app.put("/x")\ndef x():\n    db.session.commit()\n')
+    assert main([str(tmp_path)]) == EXIT_OK
+    assert main([str(tmp_path), "--fail-on", "medium"]) == EXIT_FINDINGS
+
+
+def test_json_output_is_parseable(tmp_path, capsys):
+    (tmp_path / "app.py").write_text(CHARGE)
+    main([str(tmp_path), "--json"])
+    payload = json.loads(capsys.readouterr().out)
+    assert payload["summary"]["findings"] == 1
+    assert payload["findings"][0]["severity"] == "high"
+
+
+def test_a_missing_path_is_a_usage_error(capsys):
+    assert main(["/no/such/path/here"]) == EXIT_USAGE
+    assert "no such path" in capsys.readouterr().err
+
+
+def test_version_exits_cleanly(capsys):
+    with pytest.raises(SystemExit) as exc:
+        main(["--version"])
+    assert exc.value.code == 0
+    assert capsys.readouterr().out.startswith("idemcheck ")