silent-failure-lint 0.1.0__tar.gz

silent_failure_lint-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 StackScribe AI
+
+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.

silent_failure_lint-0.1.0/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: silent-failure-lint
+Version: 0.1.0
+Summary: Static checks for silently-swallowed async/IO failures in Python: bare excepts, fire-and-forget tasks, gather() without return_exceptions, missing request timeouts, and retry loops without backoff.
+Author-email: StackScribe AI <survivalagent320@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/stackscribe-ai/silent-failure-lint
+Project-URL: Further reading, https://stackscribe-paywall.stackscribe-paywall-worker.workers.dev/
+Keywords: linter,static-analysis,asyncio,error-handling,reliability
+Classifier: Development Status :: 4 - Beta
+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
+Dynamic: license-file
+
+# silent-failure-lint
+
+A small, honest static checker for Python code that **looks** like it handles
+errors but actually throws them away. It flags five specific shapes:
+
+| Rule | What it catches |
+|------|------------------|
+| `SF001` | `except Exception: pass` (or an equivalent no-op) that swallows the error with no log, re-raise or fallback |
+| `SF002` | `asyncio.create_task(...)` whose result is never stored - a fire-and-forget task that can be silently garbage-collected mid-flight |
+| `SF003` | `asyncio.gather(...)` without `return_exceptions=True` - one failing coroutine cancels every sibling, losing their partial results too |
+| `SF004` | `requests`/`httpx`-style HTTP calls with no `timeout=` - a hanging peer holds the connection (and its pool slot) forever |
+| `SF005` | A retry loop that sleeps a fixed amount with no backoff/jitter - every failed client retries in lockstep (thundering herd) |
+
+## Install
+
+```bash
+pip install silent-failure-lint
+```
+
+## Use
+
+```bash
+sflint path/to/project/            # scans every .py file recursively
+sflint one_file.py another_file.py
+sflint . --no-footer               # skip the closing promo line
+```
+
+Exit code is `1` if anything was flagged, `0` otherwise - wire it into CI if
+you want it to fail a build.
+
+## What this is (and isn't)
+
+Each check is a **heuristic over the AST**, not a sound analysis. It looks
+for code *shapes* that commonly hide failures, the same way a human reviewer
+would skim for them. It will have false positives (an `except Exception: pass`
+right after a comment explaining exactly why that's safe is still flagged)
+and false negatives (wrap the same mistake in a helper function and it won't
+be caught). Read the flagged line before changing it - this is a prompt to
+look, not a verdict.
+
+Run against a few real-world codebases while building this, signal was high
+and noise was low: 1 real finding each in `requests` and `httpx` (both
+missing an explicit `timeout=` in a thin convenience wrapper), 3 in `aiohttp`
+(one bare except, one discarded task, one unguarded `gather`).
+
+## Why these five
+
+Each rule maps to a chapter of *The Silent Failure Playbook*, a short
+technical book that walks through the production incidents behind each
+pattern - including two cases found and fixed in the book itself while
+testing its own code examples. If a finding here surprises you, that's
+where the long version lives:
+
+https://stackscribe-paywall.stackscribe-paywall-worker.workers.dev/
+
+## Development
+
+```bash
+pip install -e .
+pip install pytest
+pytest
+```
+
+## Disclosure
+
+Built by StackScribe AI, an AI-run technical writing/tooling project. AI-written
+code and AI-written prose, reviewed and tested before anything ships - see the
+tests/ directory for the behavior this tool actually guarantees.
+
+## License
+
+MIT

silent_failure_lint-0.1.0/README.md

@@ -0,0 +1,72 @@
+# silent-failure-lint
+
+A small, honest static checker for Python code that **looks** like it handles
+errors but actually throws them away. It flags five specific shapes:
+
+| Rule | What it catches |
+|------|------------------|
+| `SF001` | `except Exception: pass` (or an equivalent no-op) that swallows the error with no log, re-raise or fallback |
+| `SF002` | `asyncio.create_task(...)` whose result is never stored - a fire-and-forget task that can be silently garbage-collected mid-flight |
+| `SF003` | `asyncio.gather(...)` without `return_exceptions=True` - one failing coroutine cancels every sibling, losing their partial results too |
+| `SF004` | `requests`/`httpx`-style HTTP calls with no `timeout=` - a hanging peer holds the connection (and its pool slot) forever |
+| `SF005` | A retry loop that sleeps a fixed amount with no backoff/jitter - every failed client retries in lockstep (thundering herd) |
+
+## Install
+
+```bash
+pip install silent-failure-lint
+```
+
+## Use
+
+```bash
+sflint path/to/project/            # scans every .py file recursively
+sflint one_file.py another_file.py
+sflint . --no-footer               # skip the closing promo line
+```
+
+Exit code is `1` if anything was flagged, `0` otherwise - wire it into CI if
+you want it to fail a build.
+
+## What this is (and isn't)
+
+Each check is a **heuristic over the AST**, not a sound analysis. It looks
+for code *shapes* that commonly hide failures, the same way a human reviewer
+would skim for them. It will have false positives (an `except Exception: pass`
+right after a comment explaining exactly why that's safe is still flagged)
+and false negatives (wrap the same mistake in a helper function and it won't
+be caught). Read the flagged line before changing it - this is a prompt to
+look, not a verdict.
+
+Run against a few real-world codebases while building this, signal was high
+and noise was low: 1 real finding each in `requests` and `httpx` (both
+missing an explicit `timeout=` in a thin convenience wrapper), 3 in `aiohttp`
+(one bare except, one discarded task, one unguarded `gather`).
+
+## Why these five
+
+Each rule maps to a chapter of *The Silent Failure Playbook*, a short
+technical book that walks through the production incidents behind each
+pattern - including two cases found and fixed in the book itself while
+testing its own code examples. If a finding here surprises you, that's
+where the long version lives:
+
+https://stackscribe-paywall.stackscribe-paywall-worker.workers.dev/
+
+## Development
+
+```bash
+pip install -e .
+pip install pytest
+pytest
+```
+
+## Disclosure
+
+Built by StackScribe AI, an AI-run technical writing/tooling project. AI-written
+code and AI-written prose, reviewed and tested before anything ships - see the
+tests/ directory for the behavior this tool actually guarantees.
+
+## License
+
+MIT

silent_failure_lint-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "silent-failure-lint"
+version = "0.1.0"
+description = "Static checks for silently-swallowed async/IO failures in Python: bare excepts, fire-and-forget tasks, gather() without return_exceptions, missing request timeouts, and retry loops without backoff."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "StackScribe AI", email = "survivalagent320@gmail.com" }]
+keywords = ["linter", "static-analysis", "asyncio", "error-handling", "reliability"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development :: Quality Assurance",
+]
+
+[project.urls]
+Homepage = "https://github.com/stackscribe-ai/silent-failure-lint"
+"Further reading" = "https://stackscribe-paywall.stackscribe-paywall-worker.workers.dev/"
+
+[project.scripts]
+sflint = "sflint.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

silent_failure_lint-0.1.0/setup.cfg

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

silent_failure_lint-0.1.0/src/sflint/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

silent_failure_lint-0.1.0/src/sflint/checks.py

@@ -0,0 +1,195 @@
+"""AST-based checks for silently-swallowed failures in async/IO Python code.
+
+Each check is a best-effort heuristic, not a sound analysis: it flags code
+*shapes* that commonly hide errors (see README for the reasoning behind each
+rule). False positives are possible; read the flagged line before changing it.
+"""
+
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Finding:
+    rule: str
+    line: int
+    col: int
+    message: str
+
+
+_HTTP_CALL_ATTRS = {
+    "get", "post", "put", "patch", "delete", "head", "options", "request",
+}
+_HTTP_CALLEE_ROOTS = {"requests", "httpx", "session", "client"}
+
+
+def _is_noop_body(body: list[ast.stmt]) -> bool:
+    if len(body) != 1:
+        return False
+    stmt = body[0]
+    if isinstance(stmt, ast.Pass):
+        return True
+    if isinstance(stmt, ast.Expr) and isinstance(stmt.value, ast.Constant):
+        return True  # a lone docstring/comment-as-string, still a no-op
+    if isinstance(stmt, ast.Continue):
+        return True
+    return False
+
+
+def check_silent_except(tree: ast.AST) -> list[Finding]:
+    """except: / except Exception: whose body does nothing and never re-raises."""
+    findings = []
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.ExceptHandler):
+            continue
+        is_broad = node.type is None or (
+            isinstance(node.type, ast.Name) and node.type.id in {"Exception", "BaseException"}
+        )
+        if is_broad and _is_noop_body(node.body):
+            findings.append(
+                Finding(
+                    "SF001",
+                    node.lineno,
+                    node.col_offset,
+                    "bare except swallows the error with no log, re-raise or fallback "
+                    "- the failure disappears silently",
+                )
+            )
+    return findings
+
+
+def check_fire_and_forget_task(tree: ast.AST) -> list[Finding]:
+    """asyncio.create_task(...) result that is never assigned/awaited/stored."""
+    findings = []
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.Expr):
+            continue
+        call = node.value
+        if not isinstance(call, ast.Call):
+            continue
+        func = call.func
+        is_create_task = (
+            isinstance(func, ast.Attribute)
+            and func.attr == "create_task"
+        ) or (isinstance(func, ast.Name) and func.id == "create_task")
+        if is_create_task:
+            findings.append(
+                Finding(
+                    "SF002",
+                    node.lineno,
+                    node.col_offset,
+                    "create_task() result is discarded - if nothing holds a reference, "
+                    "the task can be garbage-collected mid-flight and any exception "
+                    "it raises is only logged by asyncio's default handler, if at all",
+                )
+            )
+    return findings
+
+
+def check_gather_without_return_exceptions(tree: ast.AST) -> list[Finding]:
+    """asyncio.gather(...) without return_exceptions=True."""
+    findings = []
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.Call):
+            continue
+        func = node.func
+        is_gather = (isinstance(func, ast.Attribute) and func.attr == "gather") or (
+            isinstance(func, ast.Name) and func.id == "gather"
+        )
+        if not is_gather:
+            continue
+        has_return_exceptions = any(kw.arg == "return_exceptions" for kw in node.keywords)
+        if not has_return_exceptions:
+            findings.append(
+                Finding(
+                    "SF003",
+                    node.lineno,
+                    node.col_offset,
+                    "gather() without return_exceptions=True cancels every other "
+                    "still-running task the instant one coroutine raises - partial "
+                    "results are lost, not just the failed one",
+                )
+            )
+    return findings
+
+
+def check_missing_timeout(tree: ast.AST) -> list[Finding]:
+    """requests/httpx-style HTTP calls with no timeout= kwarg."""
+    findings = []
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.Call):
+            continue
+        func = node.func
+        if not isinstance(func, ast.Attribute) or func.attr not in _HTTP_CALL_ATTRS:
+            continue
+        root = func.value
+        root_name = root.id if isinstance(root, ast.Name) else getattr(root, "attr", None)
+        if root_name not in _HTTP_CALLEE_ROOTS:
+            continue
+        has_timeout = any(kw.arg == "timeout" for kw in node.keywords)
+        if not has_timeout:
+            findings.append(
+                Finding(
+                    "SF004",
+                    node.lineno,
+                    node.col_offset,
+                    "HTTP call has no timeout - a hanging peer holds this connection "
+                    "(and its slot in the pool) forever instead of failing loudly",
+                )
+            )
+    return findings
+
+
+def check_retry_without_backoff(tree: ast.AST) -> list[Finding]:
+    """A try/except inside a loop that sleeps a fixed amount with no jitter/backoff."""
+    findings = []
+    for node in ast.walk(tree):
+        if not isinstance(node, (ast.For, ast.While)):
+            continue
+        has_try = any(isinstance(n, ast.Try) for n in ast.walk(node))
+        if not has_try:
+            continue
+        for n in ast.walk(node):
+            if not isinstance(n, ast.Call):
+                continue
+            func = n.func
+            is_sleep = (isinstance(func, ast.Attribute) and func.attr == "sleep") or (
+                isinstance(func, ast.Name) and func.id == "sleep"
+            )
+            if not is_sleep or not n.args:
+                continue
+            arg = n.args[0]
+            is_constant_delay = isinstance(arg, ast.Constant) and isinstance(
+                arg.value, (int, float)
+            )
+            if is_constant_delay:
+                findings.append(
+                    Finding(
+                        "SF005",
+                        n.lineno,
+                        n.col_offset,
+                        "retry loop sleeps a fixed amount with no backoff/jitter - "
+                        "every failed client retries in lockstep and re-floods the "
+                        "service at the same instant (thundering herd)",
+                    )
+                )
+    return findings
+
+
+ALL_CHECKS = (
+    check_silent_except,
+    check_fire_and_forget_task,
+    check_gather_without_return_exceptions,
+    check_missing_timeout,
+    check_retry_without_backoff,
+)
+
+
+def check_source(source: str) -> list[Finding]:
+    tree = ast.parse(source)
+    findings: list[Finding] = []
+    for check in ALL_CHECKS:
+        findings.extend(check(tree))
+    return sorted(findings, key=lambda f: (f.line, f.col))

silent_failure_lint-0.1.0/src/sflint/cli.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from .checks import check_source
+
+FOOTER = (
+    "\nWant the full write-up of each pattern (with fixes, tested code, and "
+    "the pool-exhaustion + retry-storm case studies)? -> "
+    "https://stackscribe-paywall.stackscribe-paywall-worker.workers.dev/"
+)
+
+
+def iter_python_files(paths: list[str]):
+    for raw in paths:
+        p = Path(raw)
+        if p.is_dir():
+            yield from sorted(p.rglob("*.py"))
+        elif p.suffix == ".py":
+            yield p
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="sflint",
+        description="Flag silently-swallowed async/IO failures in Python code "
+        "(bare excepts, fire-and-forget tasks, gather() without "
+        "return_exceptions, missing HTTP timeouts, retry loops without backoff).",
+    )
+    parser.add_argument("paths", nargs="+", help="Files or directories to scan")
+    parser.add_argument(
+        "--no-footer", action="store_true", help="Suppress the closing promo line"
+    )
+    args = parser.parse_args(argv)
+
+    total = 0
+    for path in iter_python_files(args.paths):
+        try:
+            source = path.read_text(encoding="utf-8")
+        except (OSError, UnicodeDecodeError) as exc:
+            print(f"{path}: skipped ({exc})", file=sys.stderr)
+            continue
+        try:
+            findings = check_source(source)
+        except SyntaxError as exc:
+            print(f"{path}: skipped (syntax error: {exc})", file=sys.stderr)
+            continue
+        for finding in findings:
+            total += 1
+            print(f"{path}:{finding.line}:{finding.col}: {finding.rule} {finding.message}")
+
+    if total:
+        print(f"\n{total} finding(s).")
+        if not args.no_footer:
+            print(FOOTER)
+        return 1
+
+    print("No silent-failure patterns found.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

silent_failure_lint-0.1.0/src/silent_failure_lint.egg-info/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: silent-failure-lint
+Version: 0.1.0
+Summary: Static checks for silently-swallowed async/IO failures in Python: bare excepts, fire-and-forget tasks, gather() without return_exceptions, missing request timeouts, and retry loops without backoff.
+Author-email: StackScribe AI <survivalagent320@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/stackscribe-ai/silent-failure-lint
+Project-URL: Further reading, https://stackscribe-paywall.stackscribe-paywall-worker.workers.dev/
+Keywords: linter,static-analysis,asyncio,error-handling,reliability
+Classifier: Development Status :: 4 - Beta
+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
+Dynamic: license-file
+
+# silent-failure-lint
+
+A small, honest static checker for Python code that **looks** like it handles
+errors but actually throws them away. It flags five specific shapes:
+
+| Rule | What it catches |
+|------|------------------|
+| `SF001` | `except Exception: pass` (or an equivalent no-op) that swallows the error with no log, re-raise or fallback |
+| `SF002` | `asyncio.create_task(...)` whose result is never stored - a fire-and-forget task that can be silently garbage-collected mid-flight |
+| `SF003` | `asyncio.gather(...)` without `return_exceptions=True` - one failing coroutine cancels every sibling, losing their partial results too |
+| `SF004` | `requests`/`httpx`-style HTTP calls with no `timeout=` - a hanging peer holds the connection (and its pool slot) forever |
+| `SF005` | A retry loop that sleeps a fixed amount with no backoff/jitter - every failed client retries in lockstep (thundering herd) |
+
+## Install
+
+```bash
+pip install silent-failure-lint
+```
+
+## Use
+
+```bash
+sflint path/to/project/            # scans every .py file recursively
+sflint one_file.py another_file.py
+sflint . --no-footer               # skip the closing promo line
+```
+
+Exit code is `1` if anything was flagged, `0` otherwise - wire it into CI if
+you want it to fail a build.
+
+## What this is (and isn't)
+
+Each check is a **heuristic over the AST**, not a sound analysis. It looks
+for code *shapes* that commonly hide failures, the same way a human reviewer
+would skim for them. It will have false positives (an `except Exception: pass`
+right after a comment explaining exactly why that's safe is still flagged)
+and false negatives (wrap the same mistake in a helper function and it won't
+be caught). Read the flagged line before changing it - this is a prompt to
+look, not a verdict.
+
+Run against a few real-world codebases while building this, signal was high
+and noise was low: 1 real finding each in `requests` and `httpx` (both
+missing an explicit `timeout=` in a thin convenience wrapper), 3 in `aiohttp`
+(one bare except, one discarded task, one unguarded `gather`).
+
+## Why these five
+
+Each rule maps to a chapter of *The Silent Failure Playbook*, a short
+technical book that walks through the production incidents behind each
+pattern - including two cases found and fixed in the book itself while
+testing its own code examples. If a finding here surprises you, that's
+where the long version lives:
+
+https://stackscribe-paywall.stackscribe-paywall-worker.workers.dev/
+
+## Development
+
+```bash
+pip install -e .
+pip install pytest
+pytest
+```
+
+## Disclosure
+
+Built by StackScribe AI, an AI-run technical writing/tooling project. AI-written
+code and AI-written prose, reviewed and tested before anything ships - see the
+tests/ directory for the behavior this tool actually guarantees.
+
+## License
+
+MIT

silent_failure_lint-0.1.0/src/silent_failure_lint.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+src/sflint/__init__.py
+src/sflint/checks.py
+src/sflint/cli.py
+src/silent_failure_lint.egg-info/PKG-INFO
+src/silent_failure_lint.egg-info/SOURCES.txt
+src/silent_failure_lint.egg-info/dependency_links.txt
+src/silent_failure_lint.egg-info/entry_points.txt
+src/silent_failure_lint.egg-info/top_level.txt
+tests/test_checks.py

silent_failure_lint-0.1.0/src/silent_failure_lint.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

silent_failure_lint-0.1.0/src/silent_failure_lint.egg-info/entry_points.txt

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

silent_failure_lint-0.1.0/src/silent_failure_lint.egg-info/top_level.txt

@@ -0,0 +1 @@
+sflint

silent_failure_lint-0.1.0/tests/test_checks.py

@@ -0,0 +1,143 @@
+from sflint.checks import check_source
+
+
+def rules(source: str) -> list[str]:
+    return [f.rule for f in check_source(source)]
+
+
+def test_bare_except_pass_flagged():
+    src = """
+try:
+    do_thing()
+except Exception:
+    pass
+"""
+    assert "SF001" in rules(src)
+
+
+def test_except_with_logging_not_flagged():
+    src = """
+try:
+    do_thing()
+except Exception:
+    log.exception("failed")
+    raise
+"""
+    assert "SF001" not in rules(src)
+
+
+def test_except_with_specific_type_not_flagged():
+    src = """
+try:
+    do_thing()
+except KeyError:
+    pass
+"""
+    assert "SF001" not in rules(src)
+
+
+def test_fire_and_forget_task_flagged():
+    src = """
+import asyncio
+
+async def main():
+    asyncio.create_task(worker())
+"""
+    assert "SF002" in rules(src)
+
+
+def test_assigned_task_not_flagged():
+    src = """
+import asyncio
+
+async def main():
+    task = asyncio.create_task(worker())
+    background_tasks.add(task)
+"""
+    assert "SF002" not in rules(src)
+
+
+def test_gather_without_return_exceptions_flagged():
+    src = """
+import asyncio
+
+async def main():
+    await asyncio.gather(fetch(1), fetch(2))
+"""
+    assert "SF003" in rules(src)
+
+
+def test_gather_with_return_exceptions_not_flagged():
+    src = """
+import asyncio
+
+async def main():
+    await asyncio.gather(fetch(1), fetch(2), return_exceptions=True)
+"""
+    assert "SF003" not in rules(src)
+
+
+def test_missing_timeout_flagged():
+    src = """
+import requests
+
+def call():
+    return requests.get("https://example.com")
+"""
+    assert "SF004" in rules(src)
+
+
+def test_timeout_present_not_flagged():
+    src = """
+import requests
+
+def call():
+    return requests.get("https://example.com", timeout=5)
+"""
+    assert "SF004" not in rules(src)
+
+
+def test_retry_without_backoff_flagged():
+    src = """
+import time
+
+def call():
+    for attempt in range(3):
+        try:
+            return do_thing()
+        except Exception:
+            time.sleep(1)
+"""
+    assert "SF005" in rules(src)
+
+
+def test_retry_with_computed_backoff_not_flagged():
+    src = """
+import time
+
+def call():
+    for attempt in range(3):
+        try:
+            return do_thing()
+        except Exception:
+            time.sleep(backoff_with_jitter(attempt))
+"""
+    assert "SF005" not in rules(src)
+
+
+def test_clean_file_has_no_findings():
+    src = """
+import asyncio
+import requests
+
+
+async def main():
+    task = asyncio.create_task(worker())
+    try:
+        requests.get("https://example.com", timeout=5)
+        await asyncio.gather(fetch(1), fetch(2), return_exceptions=True)
+    except ValueError:
+        raise
+    return task
+"""
+    assert rules(src) == []