wouldcatch 0.1.0__py3-none-any.whl

wouldcatch/__init__.py

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

wouldcatch/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

wouldcatch/cli.py

@@ -0,0 +1,150 @@
+"""wouldcatch: would your tests catch a bug in the lines you just changed?"""
+
+import argparse
+import json
+import os
+import signal
+import subprocess
+import sys
+import tempfile
+import time
+
+from . import __version__
+from .diff import changed_lines, pick_base, repo_root
+from .mutate import find_mutants
+
+BACKUP = ".wouldcatch-backup.json"
+COLOR = sys.stdout.isatty() and not os.environ.get("NO_COLOR")
+if COLOR and os.name == "nt":
+    os.system("")  # turns on ANSI colors in the classic Windows console
+DEFAULT_CMD = f'"{sys.executable}" -m pytest -x -q -p no:cacheprovider'
+
+
+def read(path):
+    with open(path, encoding="utf-8", newline="") as f:  # keep CRLF as-is
+        return f.read()
+
+
+def write(path, text):
+    with open(path, "w", encoding="utf-8", newline="") as f:
+        f.write(text)
+
+
+def paint(text, code):
+    return f"\033[{code}m{text}\033[0m" if COLOR else text
+
+
+def run_tests(cmd, root, timeout):
+    env = dict(os.environ, PYTHONDONTWRITEBYTECODE="1")
+    # A fresh bytecode cache per run, so a stale .pyc can never hide a mutant.
+    with tempfile.TemporaryDirectory() as cache:
+        env["PYTHONPYCACHEPREFIX"] = cache
+        try:
+            p = subprocess.run(cmd, shell=True, cwd=root, env=env, timeout=timeout,
+                               stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        except subprocess.TimeoutExpired:
+            return "timeout"
+    return "passed" if p.returncode == 0 else "failed"
+
+
+def restore_stale_backup(root):
+    """If a previous run was killed mid-mutation, put the original file back."""
+    backup = root / BACKUP
+    if backup.exists():
+        for path, text in json.loads(backup.read_text(encoding="utf-8")).items():
+            write(root / path, text)
+            print(f"wouldcatch: restored {path} from an interrupted run", file=sys.stderr)
+        backup.unlink()
+
+
+def test_mutant(m, root, cmd, timeout):
+    target, backup = root / m.path, root / BACKUP
+    original = read(target)
+    backup.write_text(json.dumps({m.path: original}), encoding="utf-8")
+    try:
+        write(target, m.apply(original))
+        result = run_tests(cmd, root, timeout)
+    finally:
+        write(target, original)
+        backup.unlink()
+    return {"passed": "missed", "failed": "caught", "timeout": "caught"}[result]
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(prog="wouldcatch", description=__doc__)
+    ap.add_argument("--base", help="git ref to diff against (default: uncommitted changes, else last commit)")
+    ap.add_argument("--cmd", default=DEFAULT_CMD, help="test command (default: pytest)")
+    ap.add_argument("--max", type=int, default=50, help="max mutants to try (default: 50)")
+    ap.add_argument("--json", action="store_true", help="print results as JSON (for scripts and AI agents)")
+    ap.add_argument("--all", action="store_true", help="list caught mutants too")
+    ap.add_argument("--version", action="version", version=f"wouldcatch {__version__}")
+    args = ap.parse_args(argv)
+    signal.signal(signal.SIGTERM, lambda *_: sys.exit(143))  # still runs the restore in `finally`
+    log = (lambda *a, **k: None) if args.json else (lambda *a, **k: print(*a, file=sys.stderr, **k))
+
+    try:
+        root = repo_root()
+    except RuntimeError as e:
+        print(f"wouldcatch: {e}", file=sys.stderr)
+        return 2
+    restore_stale_backup(root)
+    base = args.base or pick_base(root)
+    try:
+        changes = changed_lines(root, base)
+    except RuntimeError as e:
+        print(f"wouldcatch: {e}", file=sys.stderr)
+        return 2
+
+    mutants = []
+    for path, lines in sorted(changes.items()):
+        text = read(root / path)
+        mutants += find_mutants(path, text, lines)
+    skipped = max(0, len(mutants) - args.max)
+    mutants = mutants[: args.max]
+
+    if not mutants:
+        msg = f"no mutable Python lines changed since {base}"
+        print(json.dumps({"base": base, "mutants": [], "message": msg}) if args.json else f"wouldcatch: {msg}")
+        return 0
+
+    log(f"wouldcatch: {len(mutants)} mutants on {sum(map(len, changes.values()))} changed lines "
+        f"in {len(changes)} file(s), base {base}")
+    t0 = time.time()
+    if run_tests(args.cmd, root, None) != "passed":
+        print("wouldcatch: your tests fail before any change. Fix them first.\n"
+              f"  command: {args.cmd}", file=sys.stderr)
+        return 2
+    timeout = max(10.0, 3 * (time.time() - t0))
+
+    for i, m in enumerate(mutants, 1):
+        log(f"  [{i}/{len(mutants)}] {m.path}:{m.line} {m.describe()}", end="\r" if sys.stderr.isatty() else "\n")
+        m.status = test_mutant(m, root, args.cmd, timeout)
+    if sys.stderr.isatty() and not args.json:
+        print(" " * 100, end="\r", file=sys.stderr)
+
+    missed = [m for m in mutants if m.status == "missed"]
+    caught = len(mutants) - len(missed)
+    if args.json:
+        print(json.dumps({
+            "base": base, "caught": caught, "missed": len(missed), "skipped": skipped,
+            "mutants": [{"file": m.path, "line": m.line, "original": m.original,
+                         "mutated": m.replacement, "status": m.status} for m in mutants],
+        }, indent=2))
+    else:
+        for m in mutants:
+            if m.status == "missed" or args.all:
+                label = paint("MISSED", "1;31") if m.status == "missed" else paint("caught", "32")
+                print(f"  {label}  {paint(f'{m.path}:{m.line}', '36')}  {m.describe()}")
+        print(paint(f"\n{caught}/{len(mutants)} caught.", "1;32" if not missed else "1"), end=" ")
+        if missed:
+            print(paint(f"{len(missed)} bug(s) your tests would not notice.", "31"),
+                  "Add a test that fails for each MISSED line.")
+        else:
+            print("Your tests would notice every one of these bugs.")
+        if skipped:
+            print(f"({skipped} more mutants not tried; raise --max to try them.)")
+    return 1 if missed else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

wouldcatch/diff.py

@@ -0,0 +1,58 @@
+"""Find which Python lines changed, using git."""
+
+import re
+import subprocess
+from pathlib import Path
+
+HUNK = re.compile(r"^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@")
+
+
+def git(*args, cwd="."):
+    out = subprocess.run(["git", *args], cwd=cwd, capture_output=True, text=True)
+    if out.returncode != 0:
+        raise RuntimeError(out.stderr.strip() or f"git {' '.join(args)} failed")
+    return out.stdout
+
+
+def repo_root(cwd="."):
+    return Path(git("rev-parse", "--show-toplevel", cwd=cwd).strip())
+
+
+def is_test_file(path):
+    p = Path(path)
+    return (
+        p.name.startswith("test_")
+        or p.name.endswith("_test.py")
+        or p.name == "conftest.py"
+        or any(part in ("tests", "test") for part in p.parts[:-1])
+    )
+
+
+def untracked(root):
+    out = git("ls-files", "--others", "--exclude-standard", "--", "*.py", cwd=root)
+    return [line for line in out.splitlines() if line]
+
+
+def pick_base(root):
+    """Uncommitted changes if there are any, otherwise the last commit."""
+    dirty = git("diff", "--name-only", "HEAD", "--", "*.py", cwd=root).strip()
+    if dirty or untracked(root):
+        return "HEAD"
+    return "HEAD~1"
+
+
+def changed_lines(root, base):
+    """Return {path: set of changed line numbers} for non-test .py files."""
+    out = git("diff", "-U0", "--no-color", "--no-ext-diff", base, "--", "*.py", cwd=root)
+    changes, path = {}, None
+    for line in out.splitlines():
+        if line.startswith("+++ "):
+            path = None if line == "+++ /dev/null" else line[6:]
+        elif path and (m := HUNK.match(line)):
+            start, count = int(m.group(1)), int(m.group(2) or 1)
+            changes.setdefault(path, set()).update(range(start, start + count))
+    if base == "HEAD":
+        for path in untracked(root):
+            n = len((root / path).read_text(encoding="utf-8", errors="replace").splitlines())
+            changes[path] = set(range(1, n + 1))
+    return {p: ls for p, ls in changes.items() if ls and not is_test_file(p)}

wouldcatch/mutate.py

@@ -0,0 +1,127 @@
+"""Plant small bugs in Python source, only on the lines you choose.
+
+Each mutant is a text edit (start, end, replacement) so the rest of the
+file, comments and formatting included, stays exactly as written.
+"""
+
+import ast
+import re
+from dataclasses import dataclass
+
+IGNORE = "wouldcatch: ignore"
+
+COMPARE = {
+    ast.Eq: ("==", "!="), ast.NotEq: ("!=", "=="),
+    ast.Lt: ("<", "<="), ast.LtE: ("<=", "<"),
+    ast.Gt: (">", ">="), ast.GtE: (">=", ">"),
+    ast.Is: (r"\bis\b", "is not"), ast.IsNot: (r"\bis\s+not\b", "is"),
+    ast.In: (r"\bin\b", "not in"), ast.NotIn: (r"\bnot\s+in\b", "in"),
+}
+BINARY = {ast.Add: ("+", "-"), ast.Sub: ("-", "+"), ast.Mult: ("*", "/"), ast.Div: ("/", "*")}
+BOOL = {ast.And: (r"\band\b", "or"), ast.Or: (r"\bor\b", "and")}
+
+
+@dataclass
+class Mutant:
+    path: str
+    line: int
+    start: int
+    end: int
+    original: str
+    replacement: str
+    status: str = "pending"
+
+    def apply(self, text):
+        return text[: self.start] + self.replacement + text[self.end :]
+
+    def describe(self, width=40):
+        short = lambda s: s if len(s) <= width else s[: width - 3] + "..."
+        return f"`{short(' '.join(self.original.split()))}` -> `{short(' '.join(self.replacement.split()))}`"
+
+
+class _Offsets:
+    """ast columns are UTF-8 byte offsets; convert them to str indexes."""
+
+    def __init__(self, text):
+        # Only \r\n, \r and \n end a line for ast; str.splitlines also splits on \f etc.
+        self.lines = re.findall(r"[^\r\n]*(?:\r\n|\r|\n|$)", text)
+        self.starts = [0]
+        for line in self.lines:
+            self.starts.append(self.starts[-1] + len(line))
+
+    def __call__(self, lineno, col):
+        line = self.lines[lineno - 1].encode("utf-8")
+        return self.starts[lineno - 1] + len(line[:col].decode("utf-8", errors="replace"))
+
+
+def _span(off, node):
+    return off(node.lineno, node.col_offset), off(node.end_lineno, node.end_col_offset)
+
+
+def find_mutants(path, text, lines):
+    """All mutants whose node starts on one of `lines` (a set of 1-based ints)."""
+    try:
+        tree = ast.parse(text)
+    except SyntaxError:
+        return []
+    off = _Offsets(text)
+    src = [line.rstrip("\r\n") for line in off.lines]
+    out = []
+
+    def add(line, start, end, replacement):
+        if line in lines and IGNORE not in src[line - 1]:
+            out.append(Mutant(path, line, start, end, text[start:end], replacement))
+
+    def swap_in_gap(line, left, right, pattern, replacement):
+        """Replace the operator that sits between two nodes."""
+        a, b = _span(off, left)[1], _span(off, right)[0]
+        gap = text[a:b]
+        m = re.search(pattern if pattern.startswith("\\") else re.escape(pattern), gap)
+        if m and gap[m.end() : m.end() + 1] != "=":  # "<" must not match inside "<="
+            add(line, a + m.start(), a + m.end(), replacement)
+
+    for node in ast.walk(tree):
+        line = getattr(node, "lineno", None)
+        if line is None:
+            continue
+        if isinstance(node, ast.Compare):
+            left = node.left
+            for op, right in zip(node.ops, node.comparators):
+                if type(op) in COMPARE:
+                    swap_in_gap(line, left, right, *COMPARE[type(op)])
+                left = right
+        elif isinstance(node, ast.BinOp) and type(node.op) in BINARY:
+            swap_in_gap(line, node.left, node.right, *BINARY[type(node.op)])
+        elif isinstance(node, ast.AugAssign) and type(node.op) in BINARY:
+            sym, rep = BINARY[type(node.op)]
+            swap_in_gap(line, node.target, node.value, sym + "=", rep + "=")
+        elif isinstance(node, ast.BoolOp):
+            for left, right in zip(node.values, node.values[1:]):
+                swap_in_gap(line, left, right, *BOOL[type(node.op)])
+        elif isinstance(node, ast.Constant):
+            if node.value is True or node.value is False:
+                add(line, *_span(off, node), str(not node.value))
+            elif type(node.value) is int:
+                add(line, *_span(off, node), str(node.value + 1))
+        elif isinstance(node, ast.UnaryOp) and isinstance(node.op, ast.Not):
+            a, b = _span(off, node.operand)
+            add(line, *_span(off, node), text[a:b])
+        elif isinstance(node, ast.Return) and node.value is not None:
+            if not (isinstance(node.value, ast.Constant) and node.value.value is None):
+                add(line, *_span(off, node.value), "None")
+        elif isinstance(node, (ast.If, ast.While)):
+            a, b = _span(off, node.test)
+            add(line, a, b, f"not ({text[a:b]})")
+
+    seen, result = set(), []
+    for m in sorted(out, key=lambda m: (m.line, m.start)):
+        key = (m.start, m.end, m.replacement)
+        if key in seen:
+            continue
+        seen.add(key)
+        try:
+            compile(m.apply(text), path, "exec")
+        except (SyntaxError, ValueError):
+            continue
+        result.append(m)
+    return result

wouldcatch-0.1.0.dist-info/METADATA

@@ -0,0 +1,170 @@
+Metadata-Version: 2.4
+Name: wouldcatch
+Version: 0.1.0
+Summary: Would your tests catch a bug in the lines you just changed? Mutation testing for your git diff.
+Author: Sahil Lenka
+License: MIT
+Project-URL: Homepage, https://github.com/Sahil-u07/wouldcatch
+Project-URL: Issues, https://github.com/Sahil-u07/wouldcatch/issues
+Keywords: mutation-testing,testing,pytest,git,code-review,ai-agents
+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 :: Testing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+<h1 align="center">wouldcatch</h1>
+
+<p align="center">
+  <b>Your tests pass. Would they catch a bug?</b><br>
+  wouldcatch plants small bugs in the lines you just changed, runs your tests, and shows the ones nobody noticed.
+</p>
+
+<p align="center">
+  <a href="https://github.com/Sahil-u07/wouldcatch/actions/workflows/ci.yml"><img src="https://github.com/Sahil-u07/wouldcatch/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
+  <img src="https://img.shields.io/badge/python-3.10%2B-blue" alt="Python 3.10+">
+  <img src="https://img.shields.io/badge/dependencies-0-brightgreen" alt="Zero dependencies">
+  <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-green" alt="MIT license"></a>
+</p>
+
+<p align="center">
+  <img src="docs/demo.gif" alt="wouldcatch finds 3 bugs the tests miss, then 0 after one more test" width="800">
+</p>
+
+```bash
+pipx install git+https://github.com/Sahil-u07/wouldcatch
+cd your-repo && wouldcatch
+```
+
+On Windows without pipx: `py -m pip install git+https://github.com/Sahil-u07/wouldcatch`, then run `wouldcatch` from PowerShell or Windows Terminal.
+
+No config. No dependencies. Works on any git repo with pytest (or any test command).
+
+## Green tests can still miss bugs
+
+You add a member discount and write two tests. Every line runs. Everything passes.
+
+```python
+def discount(price, is_member):
+    if is_member and price >= 100:
+        return price - 10
+    return price
+
+def test_member():
+    assert discount(200, True) == 190
+
+def test_guest():
+    assert discount(50, False) == 50
+```
+
+```
+$ wouldcatch
+  MISSED  shop.py:2  `and` -> `or`
+  MISSED  shop.py:2  `>=` -> `>`
+  MISSED  shop.py:2  `100` -> `101`
+
+4/7 caught. 3 bug(s) your tests would not notice.
+```
+
+Each MISSED line is a bug someone could ship and your suite would stay green:
+
+- `>=` becoming `>` means a member spending exactly 100 gets no discount. No test checks 100.
+- `and` becoming `or` gives every guest over 100 the discount. No test has a guest over 100.
+
+Add `assert discount(100, True) == 90` and `assert discount(200, False) == 200`, run it again, and you get `7/7 caught`.
+
+Coverage can't tell you this. It counts which lines ran, not whether a test would fail if they were wrong.
+
+## Why only the diff
+
+Mutation testing is the honest way to grade a test suite, but running it on a whole project can take hours, so almost nobody does. wouldcatch only mutates the lines in your `git diff`. A normal change gives 5 to 30 mutants, so it finishes while you're still writing the commit message.
+
+| | Line coverage | Whole-project mutation testing | **wouldcatch** |
+|---|---|---|---|
+| Tells you a test would fail on a bug | no | yes | **yes** |
+| Time on a typical change | seconds | minutes to hours | **seconds to a few minutes** |
+| Setup | plugin | config files | **none** |
+| Output | a percentage | a report on everything | **the exact lines to test** |
+
+## How it works
+
+1. Reads `git diff` to find the Python lines you changed. Test files are skipped.
+2. Makes one small change at a time on those lines: `<` to `<=`, `==` to `!=`, `and` to `or`, `+` to `-`, `True` to `False`, `100` to `101`, a return value to `None`, an `if` flipped.
+3. Runs your tests after each change. Tests still green means that bug would have gotten through.
+4. Puts the file back byte for byte (CRLF included) after every run, even on Ctrl+C or a killed process.
+
+## Usage
+
+```bash
+wouldcatch                                  # uncommitted changes, or the last commit if the tree is clean
+wouldcatch --base main                      # everything on this branch since main
+wouldcatch --cmd "pytest tests/unit -x -q"  # run only the tests that matter
+wouldcatch --json                           # machine-readable output for scripts and agents
+wouldcatch --all                            # list caught mutants too
+wouldcatch --max 100                        # try more mutants (default 50)
+```
+
+Exit codes: `0` all caught, `1` something missed, `2` setup problem (not a git repo, tests already failing).
+
+Skip a line on purpose:
+
+```python
+RETRY_DELAY = 5  # wouldcatch: ignore
+```
+
+## Use it everywhere
+
+**GitHub Actions**, on every pull request:
+
+```yaml
+- uses: actions/checkout@v5
+  with:
+    fetch-depth: 0
+- run: pip install git+https://github.com/Sahil-u07/wouldcatch pytest
+- run: wouldcatch --base origin/${{ github.base_ref }}
+```
+
+**pre-commit**, before every commit (with wouldcatch installed in your project environment):
+
+```yaml
+- repo: https://github.com/Sahil-u07/wouldcatch
+  rev: main
+  hooks:
+    - id: wouldcatch
+```
+
+**AI coding agents.** Agents are good at writing tests that pass and bad at writing tests that check anything. wouldcatch gives them a concrete target: make every MISSED line fail.
+
+- Claude Code: copy [`skills/wouldcatch`](skills/wouldcatch) into `.claude/skills/` in your project.
+- Any other agent: add this to `AGENTS.md`:
+
+```
+After changing Python code, run `wouldcatch --json`. For every mutant with
+"status": "missed", add a test that fails for that change. Re-run until none are missed.
+Never change the source code to make a mutant go away.
+```
+
+## FAQ
+
+**Will it mess up my files?** It edits one file at a time and restores it right after. If the process dies mid-run, the next run restores the file from `.wouldcatch-backup.json` before doing anything else.
+
+**My test suite is slow.** Each mutant is one run of your test command. Point `--cmd` at the relevant tests and use `-x` so pytest stops at the first failure.
+
+**A mutant can't be caught, the code really doesn't care.** That happens (a log interval, a cache size). Mark the line `# wouldcatch: ignore`.
+
+**JavaScript, TypeScript, Go?** Python today. The git part is language-neutral; JS/TS is next. Join [the discussion](https://github.com/Sahil-u07/wouldcatch/issues/4).
+
+## Contributing
+
+New mutations are small, self-contained PRs. Start with a [good first issue](https://github.com/Sahil-u07/wouldcatch/labels/good%20first%20issue) and see [CONTRIBUTING.md](CONTRIBUTING.md).
+
+If wouldcatch found a bug your tests missed, a star helps other people find it.
+
+## License
+
+[MIT](LICENSE)

wouldcatch-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+wouldcatch/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+wouldcatch/__main__.py,sha256=E6Gls0DNz8GQK2K-kOUIx8cYhgANW_CH54VKrfCfs14,52
+wouldcatch/cli.py,sha256=ZMt-YmYutZeQbEh_6bHepjnm9kATqUJpqv43bKfnAeg,5963
+wouldcatch/diff.py,sha256=UeGaJEk6L8TF2_DyZF2PoaBO1U5hrZkr0POTyiPkrRU,1994
+wouldcatch/mutate.py,sha256=2XR4wh2epYlJSOZwFFYPBawVOVDVeUZbmeyFidIvV6o,4950
+wouldcatch-0.1.0.dist-info/licenses/LICENSE,sha256=x68zHYUKYVZLcEHCvBoPEp-fCDtz-Z55DcXIaPNIxhE,1068
+wouldcatch-0.1.0.dist-info/METADATA,sha256=p3NwffBW89iWT5PmWbOWwR4BwSToasrF0mpByiLvANM,6882
+wouldcatch-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+wouldcatch-0.1.0.dist-info/entry_points.txt,sha256=FCuDWDV1_FdyBqLmstR7RBdJqwpWSlmTgJQokVvUfZs,51
+wouldcatch-0.1.0.dist-info/top_level.txt,sha256=GJPfR2T2fzNEmYnystHh-alS5D0aZeBnT7Hw7IMqbmU,11
+wouldcatch-0.1.0.dist-info/RECORD,,

wouldcatch-0.1.0.dist-info/WHEEL

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

wouldcatch-0.1.0.dist-info/entry_points.txt

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

wouldcatch-0.1.0.dist-info/licenses/LICENSE

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

wouldcatch-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+wouldcatch