interactive-claim-audit 0.1.0__tar.gz

interactive_claim_audit-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 interactive-claim-audit contributors
+
+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.

interactive_claim_audit-0.1.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include LICENSE README.md
+recursive-include tests *.py *.md
+include tests/fixtures/testonly/.env

interactive_claim_audit-0.1.0/PKG-INFO

@@ -0,0 +1,141 @@
+Metadata-Version: 2.4
+Name: interactive-claim-audit
+Version: 0.1.0
+Summary: Offline static audit of documented interactivity claims.
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# interactive-claim-audit
+
+Offline static audit of documented interactivity claims.
+
+Version 0.1.0 · Python 3.9+ · MIT · standard library only at runtime.
+
+Compare documentation promises about human interaction with named Python call sites. The auditor parses source without importing or executing the audited project, uses no network, skips symlinks, and skips `.env` and `.env.*` file contents.
+
+## Usage
+
+Install from a local checkout:
+
+```sh
+python3 -m pip install .
+interactive-claim-audit /path/to/project
+python3 -m interactive_claim_audit /path/to/project --json
+interactive-claim-audit /path/to/project --verbose --ignore 'vendor/*'
+interactive-claim-audit /path/to/project --fail-on HIGH
+interactive-claim-audit --version
+```
+
+The path defaults to the current directory. `--ignore GLOB` is repeatable and matches relative paths. `--verbose` adds verified families and parse warnings to text output. `--json` emits a JSON object containing `status`, `findings`, `verified_claims`, `claims`, `production_evidence`, `test_only_evidence`, and `errors`.
+
+Exit codes are 0 for PASS, 2 for findings meeting the selected threshold, and 1 for usage errors. The default threshold is MEDIUM; `--fail-on HIGH` leaves MEDIUM findings visible but permits exit 0.
+
+## Rules
+
+Documentation occurrences collapse into two families, `noninteractive` and `interactive`, evaluated independently. Each failing family produces one finding containing all applicable evidence items.
+
+| Rule | Severity | Condition |
+| --- | --- | --- |
+| `documented-noninteractive-claim-false` | HIGH | The noninteractive family has production evidence. |
+| `documented-noninteractive-claim-false-test-only` | MEDIUM | That family has evidence only in test or fixture sources. |
+| `documented-interactive-claim-false` | HIGH | The interactive family lacks production evidence and has no test evidence. |
+| `documented-interactive-claim-false-test-only` | MEDIUM | That family has evidence only in test or fixture sources. |
+
+A claimed family with no production Python files produces one HIGH finding with `no-source` evidence, taking priority over the test-only rules. With production files present, the noninteractive family is verified when evidence is absent everywhere; the interactive family is verified when production evidence exists. Verified families appear in `verified_claims`. A tree with zero documentation claims passes regardless of its call sites.
+
+## Claim vocabulary
+
+Only root `README.md` and `docs/**/*.md` supply claims. Fenced code blocks are excluded; inline code spans count as prose. Matching is case-insensitive and limited to the exact phrases below; hyphen and space spellings are accepted only where explicitly listed.
+
+```text
+NONINTERACTIVE
+non-interactive
+non interactive
+not interactive
+no prompts
+no user input
+without user input
+does not prompt
+doesn't prompt
+never prompts
+without prompting
+no interaction required
+no confirmation prompt
+no manual intervention
+does not ask
+never asks
+runs unattended
+unattended
+CI-friendly
+CI friendly
+suitable for CI
+works in CI
+
+INTERACTIVE
+interactive mode
+interactive prompt
+interactive use
+interactive confirmation
+confirmation prompt
+prompts for confirmation
+asks for confirmation
+asks the user
+prompts the user
+prompt for confirmation
+ask the user
+```
+
+Negation is asymmetric: a sentence containing `no`, `not`, `never`, `without`, `doesn't`, `don't`, `isn't`, or `does not` suppresses the interactive family. Matches in the noninteractive family still count, including its negated phrases. Overlap masking finds the noninteractive family first, masks its matched spans, and searches the remaining text for the interactive family. This prevents a substring from generating an extra family match.
+
+The bare words “interactive” and “prompt” are not claims. Paraphrases outside the vocabulary are not inferred. Contradictory documentation can supply both families; each receives its own evaluation.
+
+## Named evidence table
+
+Evidence is collected from Python AST calls and deduplicated by relative file, line, and kind. Imports and aliases are tracked per file where indicated.
+
+| Named call | Evidence treatment |
+| --- | --- |
+| `input(...)`, `builtins.input(...)` | Counts, including a locally shadowed `input`. |
+| `.getpass(...)` | Counts on any receiver spelling. |
+| Imported bare `getpass(...)` | Counts with `from getpass import getpass`, including aliases; a bare name without that import does not count. |
+| `.prompt(...)` | Counts on any receiver, including Click, Questionary objects, and toolkit sessions. |
+| `.confirm(...)` | Counts on any receiver. |
+| `questionary.<name>(...)` or imported Questionary functions | Counts with tracked module or function imports and aliases. |
+| Toolkit `prompt(...)` | Counts with a per-file `prompt_toolkit` import; imported `prompt` aliases and `shortcuts` imports are recognized. |
+
+Production evidence excludes `tests/`, `fixtures/`, test filename patterns (`test_*.py`, `*_test.py`), `docs/`, and `examples/`. Test and fixture evidence is collected separately; docs and examples supply no source evidence. Symlinked files and directories are skipped. Parse and decoding failures are reported in `errors`; they are not proof that a file lacks relevant behavior.
+
+## Differentiation
+
+| Neighbour | Its question | This tool's distinction |
+| --- | --- | --- |
+| auth-claim-audit | Are credentials required? | Examines dependence on a human, including filename and yes/no questions. `getpass` overlaps explicitly: login evidence there, human-input evidence here. |
+| error-claim-audit | Which failures occur? | Examines waiting for a person. |
+| concurrency-claim-audit | What execution model is used? | Examines human interaction. |
+| timeout-claim-audit | What time bounds apply? | Examines human blocking rather than elapsed-time guarantees. |
+| Bandit / Ruff | What code issues exist? | Compares documentation promises with source evidence. |
+| Click / Questionary / prompt_toolkit documentation | How are input primitives used? | Checks documentation against a project's source instead of teaching those APIs. |
+
+## Honest limitations
+
+This is a vocabulary-and-call-site check, not a behavioral proof. Exact-phrase claims miss paraphrases. Dead code counts: a call in an uncalled function is still evidence. Reachability, branches, flag defaults, runtime configuration, and whether a person actually sees a question are not inferred. A successful result does not prove every documented execution path behaves as intended.
+
+Receiver types are not inferred: `.prompt`, `.confirm`, and `.getpass` calls on unrelated objects or test doubles can count. A locally defined `input` also counts. Import recognition is limited to the named evidence table; dynamic imports, indirect wrappers, and arbitrary alias assignments can escape detection.
+
+Reading `sys.stdin.read`, `readline`, or `readlines`, including redirected or piped input, is not evidence. Printing and logging are not evidence. Argparse and Click option declarations are not evidence; in particular, `click.option(..., prompt=True)` is a documented gap because it is a declaration rather than a `.prompt(...)` call.
+
+Curses, Urwid, and Textual interfaces are outside scope. Other libraries such as inquirer, PyInquirer, and bullet are outside scope unless their calls independently match a named pattern. Evidence found only in tests or fixtures receives MEDIUM under the rules above; it does not establish production behavior. Negation and overlap masking follow the lexical rules above rather than natural-language understanding.
+
+## Development and packaging
+
+```sh
+PYTHONPATH=src python3 -m unittest discover -s tests -v
+python3 -m build
+# If isolated build dependencies are unavailable offline:
+python3 -m build --no-isolation
+```
+
+The build produces a wheel and source distribution in `dist/`. The source distribution includes the test fixtures through `MANIFEST.in`.

interactive_claim_audit-0.1.0/README.md

@@ -0,0 +1,131 @@
+# interactive-claim-audit
+
+Offline static audit of documented interactivity claims.
+
+Version 0.1.0 · Python 3.9+ · MIT · standard library only at runtime.
+
+Compare documentation promises about human interaction with named Python call sites. The auditor parses source without importing or executing the audited project, uses no network, skips symlinks, and skips `.env` and `.env.*` file contents.
+
+## Usage
+
+Install from a local checkout:
+
+```sh
+python3 -m pip install .
+interactive-claim-audit /path/to/project
+python3 -m interactive_claim_audit /path/to/project --json
+interactive-claim-audit /path/to/project --verbose --ignore 'vendor/*'
+interactive-claim-audit /path/to/project --fail-on HIGH
+interactive-claim-audit --version
+```
+
+The path defaults to the current directory. `--ignore GLOB` is repeatable and matches relative paths. `--verbose` adds verified families and parse warnings to text output. `--json` emits a JSON object containing `status`, `findings`, `verified_claims`, `claims`, `production_evidence`, `test_only_evidence`, and `errors`.
+
+Exit codes are 0 for PASS, 2 for findings meeting the selected threshold, and 1 for usage errors. The default threshold is MEDIUM; `--fail-on HIGH` leaves MEDIUM findings visible but permits exit 0.
+
+## Rules
+
+Documentation occurrences collapse into two families, `noninteractive` and `interactive`, evaluated independently. Each failing family produces one finding containing all applicable evidence items.
+
+| Rule | Severity | Condition |
+| --- | --- | --- |
+| `documented-noninteractive-claim-false` | HIGH | The noninteractive family has production evidence. |
+| `documented-noninteractive-claim-false-test-only` | MEDIUM | That family has evidence only in test or fixture sources. |
+| `documented-interactive-claim-false` | HIGH | The interactive family lacks production evidence and has no test evidence. |
+| `documented-interactive-claim-false-test-only` | MEDIUM | That family has evidence only in test or fixture sources. |
+
+A claimed family with no production Python files produces one HIGH finding with `no-source` evidence, taking priority over the test-only rules. With production files present, the noninteractive family is verified when evidence is absent everywhere; the interactive family is verified when production evidence exists. Verified families appear in `verified_claims`. A tree with zero documentation claims passes regardless of its call sites.
+
+## Claim vocabulary
+
+Only root `README.md` and `docs/**/*.md` supply claims. Fenced code blocks are excluded; inline code spans count as prose. Matching is case-insensitive and limited to the exact phrases below; hyphen and space spellings are accepted only where explicitly listed.
+
+```text
+NONINTERACTIVE
+non-interactive
+non interactive
+not interactive
+no prompts
+no user input
+without user input
+does not prompt
+doesn't prompt
+never prompts
+without prompting
+no interaction required
+no confirmation prompt
+no manual intervention
+does not ask
+never asks
+runs unattended
+unattended
+CI-friendly
+CI friendly
+suitable for CI
+works in CI
+
+INTERACTIVE
+interactive mode
+interactive prompt
+interactive use
+interactive confirmation
+confirmation prompt
+prompts for confirmation
+asks for confirmation
+asks the user
+prompts the user
+prompt for confirmation
+ask the user
+```
+
+Negation is asymmetric: a sentence containing `no`, `not`, `never`, `without`, `doesn't`, `don't`, `isn't`, or `does not` suppresses the interactive family. Matches in the noninteractive family still count, including its negated phrases. Overlap masking finds the noninteractive family first, masks its matched spans, and searches the remaining text for the interactive family. This prevents a substring from generating an extra family match.
+
+The bare words “interactive” and “prompt” are not claims. Paraphrases outside the vocabulary are not inferred. Contradictory documentation can supply both families; each receives its own evaluation.
+
+## Named evidence table
+
+Evidence is collected from Python AST calls and deduplicated by relative file, line, and kind. Imports and aliases are tracked per file where indicated.
+
+| Named call | Evidence treatment |
+| --- | --- |
+| `input(...)`, `builtins.input(...)` | Counts, including a locally shadowed `input`. |
+| `.getpass(...)` | Counts on any receiver spelling. |
+| Imported bare `getpass(...)` | Counts with `from getpass import getpass`, including aliases; a bare name without that import does not count. |
+| `.prompt(...)` | Counts on any receiver, including Click, Questionary objects, and toolkit sessions. |
+| `.confirm(...)` | Counts on any receiver. |
+| `questionary.<name>(...)` or imported Questionary functions | Counts with tracked module or function imports and aliases. |
+| Toolkit `prompt(...)` | Counts with a per-file `prompt_toolkit` import; imported `prompt` aliases and `shortcuts` imports are recognized. |
+
+Production evidence excludes `tests/`, `fixtures/`, test filename patterns (`test_*.py`, `*_test.py`), `docs/`, and `examples/`. Test and fixture evidence is collected separately; docs and examples supply no source evidence. Symlinked files and directories are skipped. Parse and decoding failures are reported in `errors`; they are not proof that a file lacks relevant behavior.
+
+## Differentiation
+
+| Neighbour | Its question | This tool's distinction |
+| --- | --- | --- |
+| auth-claim-audit | Are credentials required? | Examines dependence on a human, including filename and yes/no questions. `getpass` overlaps explicitly: login evidence there, human-input evidence here. |
+| error-claim-audit | Which failures occur? | Examines waiting for a person. |
+| concurrency-claim-audit | What execution model is used? | Examines human interaction. |
+| timeout-claim-audit | What time bounds apply? | Examines human blocking rather than elapsed-time guarantees. |
+| Bandit / Ruff | What code issues exist? | Compares documentation promises with source evidence. |
+| Click / Questionary / prompt_toolkit documentation | How are input primitives used? | Checks documentation against a project's source instead of teaching those APIs. |
+
+## Honest limitations
+
+This is a vocabulary-and-call-site check, not a behavioral proof. Exact-phrase claims miss paraphrases. Dead code counts: a call in an uncalled function is still evidence. Reachability, branches, flag defaults, runtime configuration, and whether a person actually sees a question are not inferred. A successful result does not prove every documented execution path behaves as intended.
+
+Receiver types are not inferred: `.prompt`, `.confirm`, and `.getpass` calls on unrelated objects or test doubles can count. A locally defined `input` also counts. Import recognition is limited to the named evidence table; dynamic imports, indirect wrappers, and arbitrary alias assignments can escape detection.
+
+Reading `sys.stdin.read`, `readline`, or `readlines`, including redirected or piped input, is not evidence. Printing and logging are not evidence. Argparse and Click option declarations are not evidence; in particular, `click.option(..., prompt=True)` is a documented gap because it is a declaration rather than a `.prompt(...)` call.
+
+Curses, Urwid, and Textual interfaces are outside scope. Other libraries such as inquirer, PyInquirer, and bullet are outside scope unless their calls independently match a named pattern. Evidence found only in tests or fixtures receives MEDIUM under the rules above; it does not establish production behavior. Negation and overlap masking follow the lexical rules above rather than natural-language understanding.
+
+## Development and packaging
+
+```sh
+PYTHONPATH=src python3 -m unittest discover -s tests -v
+python3 -m build
+# If isolated build dependencies are unavailable offline:
+python3 -m build --no-isolation
+```
+
+The build produces a wheel and source distribution in `dist/`. The source distribution includes the test fixtures through `MANIFEST.in`.

interactive_claim_audit-0.1.0/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "interactive-claim-audit"
+version = "0.1.0"
+description = "Offline static audit of documented interactivity claims."
+requires-python = ">=3.9"
+license = {text = "MIT"}
+readme = "README.md"
+dependencies = []
+
+[project.scripts]
+interactive-claim-audit = "interactive_claim_audit.__main__:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

interactive_claim_audit-0.1.0/setup.cfg

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

interactive_claim_audit-0.1.0/src/interactive_claim_audit/__init__.py

@@ -0,0 +1,2 @@
+"""Offline static audit of documented interactivity claims."""
+__version__ = '0.1.0'

interactive_claim_audit-0.1.0/src/interactive_claim_audit/__main__.py

@@ -0,0 +1,47 @@
+"""Command line entry point."""
+import argparse
+import json
+import sys
+from . import __version__
+from .audit import audit
+
+
+class Parser(argparse.ArgumentParser):
+    def error(self, message):
+        self.print_usage(sys.stderr)
+        self.exit(1, self.prog + ': error: ' + message + '\n')
+
+
+def main(argv=None):
+    parser = Parser(description='Offline static audit of documented interactivity claims.')
+    parser.add_argument('path', nargs='?', default='.')
+    parser.add_argument('--json', action='store_true', dest='as_json')
+    parser.add_argument('--verbose', action='store_true')
+    parser.add_argument('--ignore', action='append', default=[], metavar='GLOB')
+    parser.add_argument('--fail-on', choices=['MEDIUM', 'HIGH'], default='MEDIUM')
+    parser.add_argument('--version', action='version', version=__version__)
+    args = parser.parse_args(argv)
+    try:
+        result = audit(args.path, args.ignore)
+    except (OSError, ValueError) as exc:
+        parser.error(str(exc))
+    failed = any(f['severity'] == 'HIGH' or args.fail_on == 'MEDIUM' for f in result['findings'])
+    result['status'] = 'FAIL' if failed else 'PASS'
+    if args.as_json:
+        print(json.dumps(result, indent=2))
+    else:
+        print(result['status'])
+        for finding in result['findings']:
+            print(finding['severity'] + ' ' + finding['rule'])
+            for item in finding['evidence']:
+                print('  ' + item.get('path', '') + ':' + str(item.get('line', '')) + ' ' + item['kind'])
+        if args.verbose:
+            for claim in result['verified_claims']:
+                print('verified: ' + claim['family'])
+            for error in result['errors']:
+                print('parse warning: ' + error['path'] + ': ' + error['message'])
+    return 2 if failed else 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

interactive_claim_audit-0.1.0/src/interactive_claim_audit/audit.py

@@ -0,0 +1,158 @@
+"""Static documentation and prompt-call auditing; never imports audited code."""
+import ast
+import fnmatch
+import os
+from pathlib import Path
+import re
+
+NONINTERACTIVE = (
+    'non-interactive', 'non interactive', 'not interactive', 'no prompts',
+    'no user input', 'without user input', 'does not prompt', "doesn't prompt",
+    'never prompts', 'without prompting', 'no interaction required',
+    'no confirmation prompt', 'no manual intervention', 'does not ask',
+    'never asks', 'runs unattended', 'unattended', 'CI-friendly', 'CI friendly',
+    'suitable for CI', 'works in CI',
+)
+INTERACTIVE = (
+    'interactive mode', 'interactive prompt', 'interactive use',
+    'interactive confirmation', 'confirmation prompt', 'prompts for confirmation',
+    'asks for confirmation', 'asks the user', 'prompts the user',
+    'prompt for confirmation', 'ask the user',
+)
+NEGATION = re.compile(r"\b(?:no|not|never|without|doesn't|don't|isn't|does not)\b", re.I)
+
+
+def phrase_pattern(phrases):
+    return re.compile(r'(?<!\w)(?:' + '|'.join(re.escape(p) for p in sorted(phrases, key=len, reverse=True)) + r')(?!\w)', re.I)
+
+
+def extract_claims(text, path='README.md'):
+    """Return phrase occurrences with locations, excluding Markdown fences."""
+    lines = []
+    fence = None
+    for line in text.splitlines(keepends=True):
+        match = re.match(r'^\s{0,3}(`{3,}|~{3,})', line)
+        if fence:
+            lines.append('\n' if line.endswith('\n') else '')
+            if match and match[1][0] == fence[0] and len(match[1]) >= len(fence) and not line[match.end():].strip():
+                fence = None
+        elif match:
+            fence = match[1]
+            lines.append('\n' if line.endswith('\n') else '')
+        else:
+            lines.append(line)
+    prose = ''.join(lines)
+    result = []
+    for sentence in re.finditer(r'[^.!?]+(?:[.!?]|$)', prose):
+        value = sentence[0]
+        masked = list(value)
+        for match in phrase_pattern(NONINTERACTIVE).finditer(value):
+            result.append({'family': 'noninteractive', 'path': path,
+                           'line': prose.count('\n', 0, sentence.start() + match.start()) + 1,
+                           'phrase': match[0]})
+            masked[match.start():match.end()] = ' ' * len(match[0])
+        if not NEGATION.search(value):
+            for match in phrase_pattern(INTERACTIVE).finditer(''.join(masked)):
+                result.append({'family': 'interactive', 'path': path,
+                               'line': prose.count('\n', 0, sentence.start() + match.start()) + 1,
+                               'phrase': match[0]})
+    return result
+
+
+def extract_evidence(source, path):
+    tree = ast.parse(source, filename=path)
+    getpass_names = set()
+    questionary_names = set()
+    questionary_functions = set()
+    toolkit_names = set()
+    toolkit_imported = False
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                if alias.name == 'questionary':
+                    questionary_names.add(alias.asname or alias.name)
+                if alias.name == 'prompt_toolkit' or alias.name.startswith('prompt_toolkit.'):
+                    toolkit_names.add(alias.asname or alias.name.split('.')[0])
+                    toolkit_imported = True
+        elif isinstance(node, ast.ImportFrom):
+            if node.module == 'getpass':
+                getpass_names.update(a.asname or a.name for a in node.names if a.name == 'getpass')
+            if node.module == 'questionary':
+                questionary_functions.update(a.asname or a.name for a in node.names)
+            if node.module and (node.module == 'prompt_toolkit' or node.module.startswith('prompt_toolkit.')):
+                toolkit_imported = True
+                toolkit_names.update(a.asname or a.name for a in node.names if a.name == 'shortcuts')
+                toolkit_names.update(a.asname or a.name for a in node.names if a.name == 'prompt')
+    result = {}
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.Call):
+            continue
+        func = node.func
+        kind = None
+        if isinstance(func, ast.Name):
+            if func.id == 'input':
+                kind = 'input'
+            elif func.id in getpass_names:
+                kind = 'getpass'
+            elif func.id in questionary_functions:
+                kind = 'questionary'
+            elif toolkit_imported and (func.id == 'prompt' or func.id in toolkit_names and func.id != 'shortcuts'):
+                kind = 'prompt_toolkit'
+        elif isinstance(func, ast.Attribute):
+            if func.attr in ('prompt', 'confirm', 'getpass'):
+                kind = func.attr
+            elif func.attr == 'input' and isinstance(func.value, ast.Name) and func.value.id == 'builtins':
+                kind = 'input'
+            elif isinstance(func.value, ast.Name) and func.value.id in questionary_names:
+                kind = 'questionary'
+        if kind:
+            result[(path, node.lineno, kind)] = {'path': path, 'line': node.lineno, 'kind': kind}
+    return sorted(result.values(), key=lambda e: (e['path'], e['line'], e['kind']))
+
+
+def audit(root, ignore=()):
+    root = Path(root)
+    if not root.is_dir():
+        raise ValueError('audit path must be a directory')
+    claims, production, testonly, errors = [], [], [], []
+    source_count = 0
+    for directory, dirs, files in os.walk(root, followlinks=False):
+        dirs[:] = sorted(d for d in dirs if not (Path(directory) / d).is_symlink() and not any(fnmatch.fnmatch((Path(directory) / d).relative_to(root).as_posix(), p) for p in ignore))
+        for name in sorted(files):
+            file = Path(directory) / name
+            relative = file.relative_to(root)
+            path = relative.as_posix()
+            if file.is_symlink() or name == '.env' or name.startswith('.env.') or any(fnmatch.fnmatch(path, p) for p in ignore):
+                continue
+            is_doc = path == 'README.md' or (relative.parts[0] == 'docs' and file.suffix == '.md')
+            if is_doc:
+                claims.extend(extract_claims(file.read_text(encoding='utf-8'), path))
+            if file.suffix != '.py' or any(p in ('docs', 'examples') for p in relative.parts[:-1]):
+                continue
+            test = any(p in ('tests', 'fixtures') for p in relative.parts[:-1]) or name.startswith('test_') or name.endswith('_test.py')
+            if not test:
+                source_count += 1
+            try:
+                evidence = extract_evidence(file.read_text(encoding='utf-8-sig'), path)
+            except (SyntaxError, UnicodeError) as exc:
+                errors.append({'path': path, 'message': str(exc)})
+                continue
+            (testonly if test else production).extend(evidence)
+    findings, verified = [], []
+    for family in ('noninteractive', 'interactive'):
+        family_claims = [c for c in claims if c['family'] == family]
+        if not family_claims:
+            continue
+        evidence = production
+        severity, suffix = 'HIGH', ''
+        if not source_count:
+            evidence = [{'kind': 'no-source'}]
+        elif not production and testonly:
+            severity, suffix, evidence = 'MEDIUM', '-test-only', testonly
+        elif (family == 'noninteractive' and not production) or (family == 'interactive' and production):
+            verified.append({'family': family, 'claims': family_claims, 'evidence': production})
+            continue
+        findings.append({'rule': 'documented-' + family + '-claim-false' + suffix,
+                         'severity': severity, 'claims': family_claims, 'evidence': evidence})
+    return {'findings': findings, 'verified_claims': verified, 'claims': claims,
+            'production_evidence': production, 'test_only_evidence': testonly, 'errors': errors}

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

@@ -0,0 +1,141 @@
+Metadata-Version: 2.4
+Name: interactive-claim-audit
+Version: 0.1.0
+Summary: Offline static audit of documented interactivity claims.
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# interactive-claim-audit
+
+Offline static audit of documented interactivity claims.
+
+Version 0.1.0 · Python 3.9+ · MIT · standard library only at runtime.
+
+Compare documentation promises about human interaction with named Python call sites. The auditor parses source without importing or executing the audited project, uses no network, skips symlinks, and skips `.env` and `.env.*` file contents.
+
+## Usage
+
+Install from a local checkout:
+
+```sh
+python3 -m pip install .
+interactive-claim-audit /path/to/project
+python3 -m interactive_claim_audit /path/to/project --json
+interactive-claim-audit /path/to/project --verbose --ignore 'vendor/*'
+interactive-claim-audit /path/to/project --fail-on HIGH
+interactive-claim-audit --version
+```
+
+The path defaults to the current directory. `--ignore GLOB` is repeatable and matches relative paths. `--verbose` adds verified families and parse warnings to text output. `--json` emits a JSON object containing `status`, `findings`, `verified_claims`, `claims`, `production_evidence`, `test_only_evidence`, and `errors`.
+
+Exit codes are 0 for PASS, 2 for findings meeting the selected threshold, and 1 for usage errors. The default threshold is MEDIUM; `--fail-on HIGH` leaves MEDIUM findings visible but permits exit 0.
+
+## Rules
+
+Documentation occurrences collapse into two families, `noninteractive` and `interactive`, evaluated independently. Each failing family produces one finding containing all applicable evidence items.
+
+| Rule | Severity | Condition |
+| --- | --- | --- |
+| `documented-noninteractive-claim-false` | HIGH | The noninteractive family has production evidence. |
+| `documented-noninteractive-claim-false-test-only` | MEDIUM | That family has evidence only in test or fixture sources. |
+| `documented-interactive-claim-false` | HIGH | The interactive family lacks production evidence and has no test evidence. |
+| `documented-interactive-claim-false-test-only` | MEDIUM | That family has evidence only in test or fixture sources. |
+
+A claimed family with no production Python files produces one HIGH finding with `no-source` evidence, taking priority over the test-only rules. With production files present, the noninteractive family is verified when evidence is absent everywhere; the interactive family is verified when production evidence exists. Verified families appear in `verified_claims`. A tree with zero documentation claims passes regardless of its call sites.
+
+## Claim vocabulary
+
+Only root `README.md` and `docs/**/*.md` supply claims. Fenced code blocks are excluded; inline code spans count as prose. Matching is case-insensitive and limited to the exact phrases below; hyphen and space spellings are accepted only where explicitly listed.
+
+```text
+NONINTERACTIVE
+non-interactive
+non interactive
+not interactive
+no prompts
+no user input
+without user input
+does not prompt
+doesn't prompt
+never prompts
+without prompting
+no interaction required
+no confirmation prompt
+no manual intervention
+does not ask
+never asks
+runs unattended
+unattended
+CI-friendly
+CI friendly
+suitable for CI
+works in CI
+
+INTERACTIVE
+interactive mode
+interactive prompt
+interactive use
+interactive confirmation
+confirmation prompt
+prompts for confirmation
+asks for confirmation
+asks the user
+prompts the user
+prompt for confirmation
+ask the user
+```
+
+Negation is asymmetric: a sentence containing `no`, `not`, `never`, `without`, `doesn't`, `don't`, `isn't`, or `does not` suppresses the interactive family. Matches in the noninteractive family still count, including its negated phrases. Overlap masking finds the noninteractive family first, masks its matched spans, and searches the remaining text for the interactive family. This prevents a substring from generating an extra family match.
+
+The bare words “interactive” and “prompt” are not claims. Paraphrases outside the vocabulary are not inferred. Contradictory documentation can supply both families; each receives its own evaluation.
+
+## Named evidence table
+
+Evidence is collected from Python AST calls and deduplicated by relative file, line, and kind. Imports and aliases are tracked per file where indicated.
+
+| Named call | Evidence treatment |
+| --- | --- |
+| `input(...)`, `builtins.input(...)` | Counts, including a locally shadowed `input`. |
+| `.getpass(...)` | Counts on any receiver spelling. |
+| Imported bare `getpass(...)` | Counts with `from getpass import getpass`, including aliases; a bare name without that import does not count. |
+| `.prompt(...)` | Counts on any receiver, including Click, Questionary objects, and toolkit sessions. |
+| `.confirm(...)` | Counts on any receiver. |
+| `questionary.<name>(...)` or imported Questionary functions | Counts with tracked module or function imports and aliases. |
+| Toolkit `prompt(...)` | Counts with a per-file `prompt_toolkit` import; imported `prompt` aliases and `shortcuts` imports are recognized. |
+
+Production evidence excludes `tests/`, `fixtures/`, test filename patterns (`test_*.py`, `*_test.py`), `docs/`, and `examples/`. Test and fixture evidence is collected separately; docs and examples supply no source evidence. Symlinked files and directories are skipped. Parse and decoding failures are reported in `errors`; they are not proof that a file lacks relevant behavior.
+
+## Differentiation
+
+| Neighbour | Its question | This tool's distinction |
+| --- | --- | --- |
+| auth-claim-audit | Are credentials required? | Examines dependence on a human, including filename and yes/no questions. `getpass` overlaps explicitly: login evidence there, human-input evidence here. |
+| error-claim-audit | Which failures occur? | Examines waiting for a person. |
+| concurrency-claim-audit | What execution model is used? | Examines human interaction. |
+| timeout-claim-audit | What time bounds apply? | Examines human blocking rather than elapsed-time guarantees. |
+| Bandit / Ruff | What code issues exist? | Compares documentation promises with source evidence. |
+| Click / Questionary / prompt_toolkit documentation | How are input primitives used? | Checks documentation against a project's source instead of teaching those APIs. |
+
+## Honest limitations
+
+This is a vocabulary-and-call-site check, not a behavioral proof. Exact-phrase claims miss paraphrases. Dead code counts: a call in an uncalled function is still evidence. Reachability, branches, flag defaults, runtime configuration, and whether a person actually sees a question are not inferred. A successful result does not prove every documented execution path behaves as intended.
+
+Receiver types are not inferred: `.prompt`, `.confirm`, and `.getpass` calls on unrelated objects or test doubles can count. A locally defined `input` also counts. Import recognition is limited to the named evidence table; dynamic imports, indirect wrappers, and arbitrary alias assignments can escape detection.
+
+Reading `sys.stdin.read`, `readline`, or `readlines`, including redirected or piped input, is not evidence. Printing and logging are not evidence. Argparse and Click option declarations are not evidence; in particular, `click.option(..., prompt=True)` is a documented gap because it is a declaration rather than a `.prompt(...)` call.
+
+Curses, Urwid, and Textual interfaces are outside scope. Other libraries such as inquirer, PyInquirer, and bullet are outside scope unless their calls independently match a named pattern. Evidence found only in tests or fixtures receives MEDIUM under the rules above; it does not establish production behavior. Negation and overlap masking follow the lexical rules above rather than natural-language understanding.
+
+## Development and packaging
+
+```sh
+PYTHONPATH=src python3 -m unittest discover -s tests -v
+python3 -m build
+# If isolated build dependencies are unavailable offline:
+python3 -m build --no-isolation
+```
+
+The build produces a wheel and source distribution in `dist/`. The source distribution includes the test fixtures through `MANIFEST.in`.

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

@@ -0,0 +1,25 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+src/interactive_claim_audit/__init__.py
+src/interactive_claim_audit/__main__.py
+src/interactive_claim_audit/audit.py
+src/interactive_claim_audit.egg-info/PKG-INFO
+src/interactive_claim_audit.egg-info/SOURCES.txt
+src/interactive_claim_audit.egg-info/dependency_links.txt
+src/interactive_claim_audit.egg-info/entry_points.txt
+src/interactive_claim_audit.egg-info/top_level.txt
+tests/test_audit.py
+tests/fixtures/bad/interactive/README.md
+tests/fixtures/bad/interactive/main.py
+tests/fixtures/bad/noninteractive/README.md
+tests/fixtures/bad/noninteractive/main.py
+tests/fixtures/good/interactive/README.md
+tests/fixtures/good/interactive/main.py
+tests/fixtures/good/noninteractive/README.md
+tests/fixtures/good/noninteractive/main.py
+tests/fixtures/testonly/.env
+tests/fixtures/testonly/README.md
+tests/fixtures/testonly/main.py
+tests/fixtures/testonly/tests/test_work.py

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,2 @@
+[console_scripts]
+interactive-claim-audit = interactive_claim_audit.__main__:main

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

@@ -0,0 +1 @@
+interactive_claim_audit

interactive_claim_audit-0.1.0/tests/fixtures/bad/interactive/README.md

@@ -0,0 +1 @@
+This tool prompts for confirmation.

interactive_claim_audit-0.1.0/tests/fixtures/bad/interactive/main.py

@@ -0,0 +1 @@
+print("done")

interactive_claim_audit-0.1.0/tests/fixtures/bad/noninteractive/README.md

@@ -0,0 +1 @@
+This tool runs unattended.

interactive_claim_audit-0.1.0/tests/fixtures/bad/noninteractive/main.py

@@ -0,0 +1 @@
+input("Continue? ")

interactive_claim_audit-0.1.0/tests/fixtures/good/interactive/README.md

@@ -0,0 +1 @@
+This tool prompts for confirmation.

interactive_claim_audit-0.1.0/tests/fixtures/good/interactive/main.py

@@ -0,0 +1 @@
+input("Continue? ")

interactive_claim_audit-0.1.0/tests/fixtures/good/noninteractive/README.md

@@ -0,0 +1 @@
+This tool runs unattended.

interactive_claim_audit-0.1.0/tests/fixtures/good/noninteractive/main.py

@@ -0,0 +1 @@
+print("done")

interactive_claim_audit-0.1.0/tests/fixtures/testonly/.env

@@ -0,0 +1 @@
+CLAIM_AUDIT_MARKER_ONLY_NOT_A_SECRET

interactive_claim_audit-0.1.0/tests/fixtures/testonly/README.md

@@ -0,0 +1 @@
+This tool runs unattended.

interactive_claim_audit-0.1.0/tests/fixtures/testonly/main.py

@@ -0,0 +1 @@
+print("done")

interactive_claim_audit-0.1.0/tests/fixtures/testonly/tests/test_work.py

@@ -0,0 +1,2 @@
+def work():
+    input("Continue? ")

interactive_claim_audit-0.1.0/tests/test_audit.py

@@ -0,0 +1,258 @@
+import contextlib
+import io
+import json
+from pathlib import Path
+import tempfile
+import unittest
+from unittest.mock import patch
+from interactive_claim_audit.audit import audit, extract_claims, extract_evidence, NONINTERACTIVE, INTERACTIVE
+from interactive_claim_audit.__main__ import main
+
+FIXTURES = Path(__file__).parent / 'fixtures'
+
+
+class Claims(unittest.TestCase):
+    def families(self, text):
+        return {c['family'] for c in extract_claims(text)}
+
+    def test_overlap(self):
+        self.assertEqual(self.families('no confirmation prompt'), {'noninteractive'})
+
+    def test_not_interactive(self):
+        self.assertEqual(self.families('this tool is not interactive'), {'noninteractive'})
+
+    def test_not_prompt_user(self):
+        self.assertEqual(self.families('does not prompt the user'), {'noninteractive'})
+
+    def test_bare_adjective(self):
+        self.assertFalse(self.families('an interactive tool'))
+
+    def test_bare_noun(self):
+        self.assertFalse(self.families('prompt engineering'))
+
+    def test_negation(self):
+        self.assertFalse(self.families('does not run in interactive mode'))
+
+    def test_fenced(self):
+        self.assertFalse(self.families('```text\nruns unattended\n```'))
+
+    def test_tilde_fenced(self):
+        self.assertFalse(self.families('~~~~\ninteractive mode\n~~~~'))
+
+    def test_inline(self):
+        self.assertEqual(self.families('`interactive mode`'), {'interactive'})
+
+    def test_sentence_scope(self):
+        self.assertEqual(self.families('Not supported. Interactive mode.'), {'interactive'})
+
+    def test_exact_phrases(self):
+        self.assertFalse(self.families('prompts for user confirmation; runs fully unattendedly'))
+
+    def test_boundary(self):
+        self.assertFalse(self.families('xnon-interactive; interactive modes'))
+
+    def test_line_number(self):
+        self.assertEqual(extract_claims('```\nno prompts\n```\nno prompts')[0]['line'], 4)
+
+
+class Evidence(unittest.TestCase):
+    def check(self, code, count=1):
+        self.assertEqual(len(extract_evidence(code, 'main.py')), count)
+
+    def test_input(self): self.check('input()')
+    def test_builtin(self): self.check('builtins.input()')
+    def test_getpass_attribute(self): self.check('getpass.getpass()')
+    def test_any_getpass_receiver(self): self.check('obj.getpass()')
+    def test_getpass_bare_unimported(self): self.check('getpass()', 0)
+    def test_getpass_import(self): self.check('from getpass import getpass\ngetpass()')
+    def test_getpass_alias(self): self.check('from getpass import getpass as gp\ngp()')
+    def test_prompt(self): self.check('obj.prompt()')
+    def test_confirm(self): self.check('obj.confirm()')
+    def test_questionary(self): self.check('import questionary\nquestionary.text()')
+    def test_questionary_alias(self): self.check('import questionary as q\nq.text()')
+    def test_questionary_from(self): self.check('from questionary import text as t\nt()')
+    def test_questionary_unimported(self): self.check('questionary.text()', 0)
+    def test_toolkit(self): self.check('from prompt_toolkit import prompt\nprompt()')
+    def test_toolkit_alias(self): self.check('from prompt_toolkit import prompt as p\np()')
+    def test_toolkit_module(self): self.check('import prompt_toolkit\nprompt()')
+    def test_toolkit_shortcuts(self): self.check('from prompt_toolkit import shortcuts\nprompt()')
+    def test_prompt_bare(self): self.check('prompt()', 0)
+    def test_stdin(self): self.check('sys.stdin.readline()\nsys.stdin.read()\nsys.stdin.readlines()', 0)
+    def test_print(self): self.check('print("hello")', 0)
+    def test_option(self): self.check('click.option("--yes", prompt=True)', 0)
+    def test_local_input(self): self.check('def input(): pass\ninput()')
+    def test_dead_code(self): self.check('def unused():\n    input()')
+    def test_dedupe(self): self.check('obj.prompt(); obj.prompt()')
+    def test_separate_lines(self): self.check('input()\ninput()', 2)
+
+
+class Audit(unittest.TestCase):
+    def setUp(self):
+        self.temp = tempfile.TemporaryDirectory()
+        self.addCleanup(self.temp.cleanup)
+        self.root = Path(self.temp.name)
+
+    def write(self, path, text):
+        p = self.root / path
+        p.parent.mkdir(parents=True, exist_ok=True)
+        p.write_text(text, encoding='utf-8')
+
+    def test_no_claim(self):
+        self.write('main.py', 'input()')
+        self.assertFalse(audit(self.root)['findings'])
+
+    def test_ignore(self):
+        self.write('README.md', 'no prompts')
+        self.write('main.py', 'pass')
+        self.write('extra.py', 'input()')
+        self.assertFalse(audit(self.root, ['extra.py'])['findings'])
+
+    def test_both_families_no_source(self):
+        self.write('README.md', 'runs unattended. Interactive mode.')
+        findings = audit(self.root)['findings']
+        self.assertEqual(len(findings), 2)
+        self.assertTrue(all(f['severity'] == 'HIGH' and f['evidence'] == [{'kind': 'no-source'}] for f in findings))
+
+    def test_both_families_test_only(self):
+        self.write('README.md', 'runs unattended. Interactive mode.')
+        self.write('main.py', 'pass')
+        self.write('tests/test_x.py', 'input()')
+        self.assertEqual(len(audit(self.root)['findings']), 2)
+
+    def test_interactive_test_only(self):
+        self.write('README.md', 'interactive mode')
+        self.write('main.py', 'pass')
+        self.write('fixtures/x.py', 'input()')
+        self.assertEqual(audit(self.root)['findings'][0]['rule'], 'documented-interactive-claim-false-test-only')
+
+    def test_all_evidence_one_finding(self):
+        self.write('README.md', 'no prompts. runs unattended.')
+        self.write('main.py', 'input()\nobj.confirm()')
+        result = audit(self.root)
+        self.assertEqual(len(result['findings']), 1)
+        self.assertEqual(len(result['findings'][0]['evidence']), 2)
+
+    def test_docs_scope(self):
+        self.write('other.md', 'no prompts')
+        self.write('docs/nested/a.md', 'interactive mode')
+        self.write('main.py', 'input()')
+        self.assertEqual([v['family'] for v in audit(self.root)['verified_claims']], ['interactive'])
+
+    def test_excluded_sources(self):
+        self.write('README.md', 'no prompts')
+        self.write('main.py', 'pass')
+        for path in ('docs/x.py', 'examples/x.py'):
+            self.write(path, 'input()')
+        self.assertFalse(audit(self.root)['findings'])
+
+    def test_test_filename(self):
+        self.write('README.md', 'no prompts')
+        self.write('main.py', 'pass')
+        self.write('unit_test.py', 'input()')
+        self.assertEqual(audit(self.root)['findings'][0]['severity'], 'MEDIUM')
+
+    def test_symlink(self):
+        self.write('README.md', 'no prompts')
+        self.write('main.py', 'pass')
+        (self.root / 'linked.py').symlink_to(FIXTURES / 'bad/noninteractive/main.py')
+        (self.root / 'linked_dir').symlink_to(FIXTURES / 'bad/noninteractive', target_is_directory=True)
+        self.assertFalse(audit(self.root)['findings'])
+
+    def test_env_never_opened(self):
+        original = Path.open
+        def guarded(path, *args, **kwargs):
+            self.assertNotEqual(path.name, '.env')
+            return original(path, *args, **kwargs)
+        output = io.StringIO()
+        with patch.object(Path, 'open', guarded), contextlib.redirect_stdout(output):
+            self.assertEqual(main([str(FIXTURES / 'testonly'), '--json']), 2)
+        self.assertNotIn('CLAIM_AUDIT_MARKER_ONLY_NOT_A_SECRET', output.getvalue())
+
+    def test_parse_warning(self):
+        self.write('main.py', 'def !')
+        self.assertEqual(len(audit(self.root)['errors']), 1)
+
+    def test_imports_are_per_file(self):
+        self.write('README.md', 'no prompts')
+        self.write('a.py', 'from getpass import getpass')
+        self.write('b.py', 'getpass()')
+        self.assertFalse(audit(self.root)['findings'])
+
+
+class CLI(unittest.TestCase):
+    def run_cli(self, args):
+        out = io.StringIO()
+        with contextlib.redirect_stdout(out):
+            code = main(args)
+        return code, out.getvalue()
+
+    def test_good_noninteractive(self):
+        code, out = self.run_cli([str(FIXTURES / 'good/noninteractive'), '--json'])
+        self.assertEqual(code, 0)
+        self.assertEqual(json.loads(out)['verified_claims'][0]['family'], 'noninteractive')
+
+    def test_good_interactive(self):
+        code, out = self.run_cli([str(FIXTURES / 'good/interactive'), '--json'])
+        self.assertEqual(code, 0)
+        self.assertEqual(json.loads(out)['verified_claims'][0]['family'], 'interactive')
+
+    def test_bad_noninteractive(self): self.bad('noninteractive')
+    def test_bad_interactive(self): self.bad('interactive')
+    def bad(self, family):
+        code, out = self.run_cli([str(FIXTURES / ('bad/' + family)), '--json'])
+        findings = json.loads(out)['findings']
+        self.assertEqual(code, 2)
+        self.assertEqual(len(findings), 1)
+        self.assertEqual(findings[0]['rule'], 'documented-' + family + '-claim-false')
+        self.assertEqual(findings[0]['severity'], 'HIGH')
+
+    def test_medium(self):
+        code, out = self.run_cli([str(FIXTURES / 'testonly'), '--json'])
+        self.assertEqual(code, 2)
+        findings = json.loads(out)['findings']
+        self.assertEqual(len(findings), 1)
+        self.assertEqual(findings[0]['severity'], 'MEDIUM')
+        self.assertEqual(findings[0]['rule'], 'documented-noninteractive-claim-false-test-only')
+
+    def test_threshold(self):
+        code, out = self.run_cli([str(FIXTURES / 'testonly'), '--fail-on', 'HIGH', '--json'])
+        self.assertEqual(code, 0)
+        self.assertEqual(json.loads(out)['findings'][0]['severity'], 'MEDIUM')
+
+    def test_version(self):
+        with self.assertRaises(SystemExit) as cm:
+            _, out = self.run_cli(['--version'])
+        self.assertEqual(cm.exception.code, 0)
+        output = io.StringIO()
+        with contextlib.redirect_stdout(output), self.assertRaises(SystemExit):
+            main(['--version'])
+        self.assertEqual(output.getvalue().strip(), '0.1.0')
+
+    def test_usage_error(self):
+        with contextlib.redirect_stderr(io.StringIO()), self.assertRaises(SystemExit) as cm:
+            main(['--unknown'])
+        self.assertEqual(cm.exception.code, 1)
+
+    def test_invalid_path(self):
+        with contextlib.redirect_stderr(io.StringIO()), self.assertRaises(SystemExit) as cm:
+            main(['/nonexistent/claim-audit-path'])
+        self.assertEqual(cm.exception.code, 1)
+
+    def test_verbose(self):
+        code, out = self.run_cli([str(FIXTURES / 'good/interactive'), '--verbose'])
+        self.assertEqual(code, 0)
+        self.assertIn('verified: interactive', out)
+
+
+# Each exact phrase is independently pinned, including capitalization.
+def phrase_test(phrase, family):
+    def test(self):
+        self.assertEqual(self.families(phrase.upper()), {family})
+    return test
+
+for family, phrases in [('noninteractive', NONINTERACTIVE), ('interactive', INTERACTIVE)]:
+    for index, phrase in enumerate(phrases):
+        setattr(Claims, 'test_phrase_' + family + '_' + str(index), phrase_test(phrase, family))
+
+if __name__ == '__main__':
+    unittest.main()