streaming-claim-audit 0.1.0__tar.gz

streaming_claim_audit-0.1.0/LICENSE

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

streaming_claim_audit-0.1.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include LICENSE README.md
+recursive-include tests *.py *.md

streaming_claim_audit-0.1.0/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: streaming-claim-audit
+Version: 0.1.0
+Summary: Offline static audit of documented streaming and low-memory claims
+Author: streaming-claim-audit contributors
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# streaming-claim-audit
+
+Version 0.1.0. An offline, stdlib-only CLI that compares documented streaming
+and low-memory promises with static whole-input loading patterns in Python
+source. It never executes audited code, makes network requests, or opens
+`.env` files. No runtime dependencies. Requires Python 3.9 or newer.
+
+## Install and use
+
+```sh
+python3 -m pip install .
+streaming-claim-audit /path/to/project
+python3 -m streaming_claim_audit /path/to/project --json
+streaming-claim-audit --version
+streaming-claim-audit tests/fixtures/testonly --fail-on HIGH
+streaming-claim-audit . --verbose --ignore documented-streaming-claim-false
+```
+
+The path defaults to `.`. Exit codes: **0 PASS**, **2 FAIL**, **1 usage/input
+error**. The default `--fail-on MEDIUM` fails for HIGH or MEDIUM;
+`--fail-on HIGH` still prints MEDIUM findings but allows them to pass.
+`--ignore RULE,...` removes named rules entirely. `--verbose` prints verified
+claims. `--json` emits an object with `findings`, `verified_claims`, and
+`summary`; each finding includes its documentation location and all evidence
+locations. A verified claim means no matching evidence was found, not a proof.
+
+## Scope and rules
+
+Claims come only from root `README.md` and `docs/**/*.md`. Fenced code is
+excluded; inline code counts. Negation suppresses the corresponding family
+within a sentence. Streaming stems include stream, incremental, line-by-line,
+lazy/lazily, iterator-based and yields. Low-memory stems include low memory,
+constant memory, memory efficient, minimal memory and large file variants.
+
+Production source includes recursive `*.py` files except `tests/`, `fixtures/`,
+`docs/`, `examples/`, `test_*.py`, and `*_test.py`. Symlinked files and
+directories are skipped, as are `.git`, `.venv`, `venv`, `__pycache__`, `build`,
+and `dist` directories. Files and directories beginning with `.env` are never
+opened. Invalid source syntax or unreadable inputs produce an input error.
+
+Each family produces at most one finding, carrying every relevant evidence
+item. Production evidence, or claims without production source, yields HIGH:
+
+- `documented-streaming-claim-false`
+- `documented-low-memory-claim-false`
+
+Evidence confined to test/fixture code yields MEDIUM:
+
+- `documented-streaming-claim-false-test-only`
+- `documented-low-memory-claim-false-test-only`
+
+Evidence includes whole-file `read_text`, `read_bytes`, unbounded file `read`,
+`readlines`, file/list and CSV materialization, file-derived JSON loading and
+pandas whole-frame call patterns. Direct file iteration, literal-size chunked
+reads, line iteration with `json.loads(line)`, directly iterated CSV readers,
+and generators do not count. No documented claims means PASS, regardless of
+evidence. There are no reverse rules for undocumented streaming behavior.
+
+## Differentiation
+
+Memory profilers and tracemalloc observe runtime allocations; this tool checks
+documentation promises against source without running the target. Bandit and
+Ruff flag code patterns without relating them to those promises.
+format-claim-audit checks which formats are supported, readonly-claim-audit
+checks writes, and schema-claim-audit checks field names. None checks how much
+input is held in memory. `wc` and file-size tools measure actual input bytes
+rather than comparing documentation with implementation.
+
+## Honest limitations
+
+This is static pattern matching, not semantic judgement or a memory profiler.
+Dead and unreachable code counts. Whole-file configuration reads may be small
+and harmless, and a project may expose both streaming and non-streaming APIs;
+findings require human review. Variable file objects and file-derived text are
+tracked only through simple same-function assignments, not across calls,
+containers or complex control flow. Import aliases are not generally resolved.
+Pandas call-name matching (`pandas` and `pd`) does not verify imports; a
+`chunksize` keyword suppresses it regardless of its value. Chunked-read detection
+recognizes only literal nonnegative integer sizes; computed sizes may be flagged.
+Arbitrary third-party loaders, wrappers, and memory growth outside the listed
+patterns are not detected. Negation and sentence extraction are heuristic,
+not a natural-language understanding system. No evidence is not proof of
+bounded memory. This auditor itself loads source and documentation into memory.
+
+## Development and validation
+
+```sh
+PYTHONPATH=src python3 -m unittest discover -s tests -v
+python3 -m build
+```
+
+The sdist includes tests and fixtures via `MANIFEST.in`. The good fixture
+passes with a verified STREAMING claim. The bad fixture produces exactly two
+HIGH findings. The testonly fixture produces two MEDIUM findings and passes
+only when `--fail-on HIGH` is used (or the relevant rules are ignored).
+
+Licensed under the MIT License; see LICENSE.

streaming_claim_audit-0.1.0/README.md

@@ -0,0 +1,97 @@
+# streaming-claim-audit
+
+Version 0.1.0. An offline, stdlib-only CLI that compares documented streaming
+and low-memory promises with static whole-input loading patterns in Python
+source. It never executes audited code, makes network requests, or opens
+`.env` files. No runtime dependencies. Requires Python 3.9 or newer.
+
+## Install and use
+
+```sh
+python3 -m pip install .
+streaming-claim-audit /path/to/project
+python3 -m streaming_claim_audit /path/to/project --json
+streaming-claim-audit --version
+streaming-claim-audit tests/fixtures/testonly --fail-on HIGH
+streaming-claim-audit . --verbose --ignore documented-streaming-claim-false
+```
+
+The path defaults to `.`. Exit codes: **0 PASS**, **2 FAIL**, **1 usage/input
+error**. The default `--fail-on MEDIUM` fails for HIGH or MEDIUM;
+`--fail-on HIGH` still prints MEDIUM findings but allows them to pass.
+`--ignore RULE,...` removes named rules entirely. `--verbose` prints verified
+claims. `--json` emits an object with `findings`, `verified_claims`, and
+`summary`; each finding includes its documentation location and all evidence
+locations. A verified claim means no matching evidence was found, not a proof.
+
+## Scope and rules
+
+Claims come only from root `README.md` and `docs/**/*.md`. Fenced code is
+excluded; inline code counts. Negation suppresses the corresponding family
+within a sentence. Streaming stems include stream, incremental, line-by-line,
+lazy/lazily, iterator-based and yields. Low-memory stems include low memory,
+constant memory, memory efficient, minimal memory and large file variants.
+
+Production source includes recursive `*.py` files except `tests/`, `fixtures/`,
+`docs/`, `examples/`, `test_*.py`, and `*_test.py`. Symlinked files and
+directories are skipped, as are `.git`, `.venv`, `venv`, `__pycache__`, `build`,
+and `dist` directories. Files and directories beginning with `.env` are never
+opened. Invalid source syntax or unreadable inputs produce an input error.
+
+Each family produces at most one finding, carrying every relevant evidence
+item. Production evidence, or claims without production source, yields HIGH:
+
+- `documented-streaming-claim-false`
+- `documented-low-memory-claim-false`
+
+Evidence confined to test/fixture code yields MEDIUM:
+
+- `documented-streaming-claim-false-test-only`
+- `documented-low-memory-claim-false-test-only`
+
+Evidence includes whole-file `read_text`, `read_bytes`, unbounded file `read`,
+`readlines`, file/list and CSV materialization, file-derived JSON loading and
+pandas whole-frame call patterns. Direct file iteration, literal-size chunked
+reads, line iteration with `json.loads(line)`, directly iterated CSV readers,
+and generators do not count. No documented claims means PASS, regardless of
+evidence. There are no reverse rules for undocumented streaming behavior.
+
+## Differentiation
+
+Memory profilers and tracemalloc observe runtime allocations; this tool checks
+documentation promises against source without running the target. Bandit and
+Ruff flag code patterns without relating them to those promises.
+format-claim-audit checks which formats are supported, readonly-claim-audit
+checks writes, and schema-claim-audit checks field names. None checks how much
+input is held in memory. `wc` and file-size tools measure actual input bytes
+rather than comparing documentation with implementation.
+
+## Honest limitations
+
+This is static pattern matching, not semantic judgement or a memory profiler.
+Dead and unreachable code counts. Whole-file configuration reads may be small
+and harmless, and a project may expose both streaming and non-streaming APIs;
+findings require human review. Variable file objects and file-derived text are
+tracked only through simple same-function assignments, not across calls,
+containers or complex control flow. Import aliases are not generally resolved.
+Pandas call-name matching (`pandas` and `pd`) does not verify imports; a
+`chunksize` keyword suppresses it regardless of its value. Chunked-read detection
+recognizes only literal nonnegative integer sizes; computed sizes may be flagged.
+Arbitrary third-party loaders, wrappers, and memory growth outside the listed
+patterns are not detected. Negation and sentence extraction are heuristic,
+not a natural-language understanding system. No evidence is not proof of
+bounded memory. This auditor itself loads source and documentation into memory.
+
+## Development and validation
+
+```sh
+PYTHONPATH=src python3 -m unittest discover -s tests -v
+python3 -m build
+```
+
+The sdist includes tests and fixtures via `MANIFEST.in`. The good fixture
+passes with a verified STREAMING claim. The bad fixture produces exactly two
+HIGH findings. The testonly fixture produces two MEDIUM findings and passes
+only when `--fail-on HIGH` is used (or the relevant rules are ignored).
+
+Licensed under the MIT License; see LICENSE.

streaming_claim_audit-0.1.0/pyproject.toml

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

streaming_claim_audit-0.1.0/setup.cfg

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

streaming_claim_audit-0.1.0/src/streaming_claim_audit/__init__.py

@@ -0,0 +1,2 @@
+"""Offline documentation streaming-claim auditor."""
+__version__ = '0.1.0'

streaming_claim_audit-0.1.0/src/streaming_claim_audit/__main__.py

@@ -0,0 +1,44 @@
+"""Command-line interface; audited code is never imported or executed."""
+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(prog='streaming-claim-audit')
+    parser.add_argument('path', nargs='?', default='.')
+    parser.add_argument('--version', action='version', version=__version__)
+    parser.add_argument('--json', action='store_true')
+    parser.add_argument('--verbose', action='store_true')
+    parser.add_argument('--ignore', default='', metavar='RULE,...')
+    parser.add_argument('--fail-on', choices=('MEDIUM', 'HIGH'), default='MEDIUM')
+    args = parser.parse_args(argv)
+    try:
+        result = audit(args.path, {r.strip() for r in args.ignore.split(',')}, args.fail_on)
+    except (OSError, ValueError, SyntaxError, UnicodeError) as error:
+        print('streaming-claim-audit: error: ' + str(error), file=sys.stderr)
+        return 1
+    if args.json:
+        print(json.dumps(result, indent=2))
+    else:
+        for finding in result['findings']:
+            print('{severity} {rule} {file}:{line} {message}'.format(**finding))
+            for item in finding['evidence']:
+                print('  {file}:{line} {kind}'.format(**item))
+        if args.verbose:
+            for claim in result['verified_claims']:
+                print('VERIFIED {family} {file}:{line}'.format(**claim))
+        print(result['summary']['status'])
+    return 2 if result['summary']['status'] == 'FAIL' else 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

streaming_claim_audit-0.1.0/src/streaming_claim_audit/audit.py

@@ -0,0 +1,187 @@
+"""Conservative AST evidence and Markdown claim extraction."""
+import ast
+import os
+import re
+from pathlib import Path
+
+PATTERNS = {
+    'STREAMING': r'\b(?:stream\w*|incremental\w*|line[ -]by[ -]line|lazy|lazily|iterator[ -]based|yields)\b',
+    'LOW_MEMORY': r'\b(?:low[ -]memory|constant[ -]memory|memory[ -]efficient|minimal memory|large[ -]files?)\b',
+}
+RULES = {family: 'documented-' + family.lower().replace('_', '-') + '-claim-false'
+         for family in PATTERNS}
+
+
+def claims(text, filename='README.md'):
+    """Return one location per family; ignore fenced examples and negations."""
+    result = {}
+    fence = None
+    prose = []
+    for number, line in enumerate(text.splitlines(), 1):
+        marker = re.match(r'^\s{0,3}(`{3,}|~{3,})', line)
+        if marker:
+            token = marker.group(1)
+            if fence is None:
+                fence = token
+            elif token[0] == fence[0] and len(token) >= len(fence):
+                fence = None
+            prose.append('')
+        else:
+            prose.append(line if fence is None else '')
+    joined = '\n'.join(prose)
+    for match in re.finditer(r'[^.!?]+(?:[.!?]|$)', joined):
+        sentence = match.group()
+        normalized = re.sub(r'[`*_]', '', sentence.lower()).replace('-', ' ')
+        for family, pattern in PATTERNS.items():
+            hit = re.search(pattern, sentence, re.I)
+            if not hit:
+                continue
+            # Negation attached to a family phrase suppresses that family only.
+            family_pattern = pattern.replace('[ -]', ' ')
+            negated = re.search(
+                r'\b(?:not|never|no|without|does not|do not|is not)\s+'
+                r'(?:(?:support|use|provide|offer|guarantee|a|any)\s+){0,3}'
+                + family_pattern, normalized, re.I)
+            if not negated:
+                line = joined.count('\n', 0, match.start() + hit.start()) + 1
+                result.setdefault(family, {'family': family, 'file': filename, 'line': line})
+    return result
+
+
+def name(node):
+    if isinstance(node, ast.Name):
+        return node.id
+    if isinstance(node, ast.Attribute):
+        return name(node.value) + '.' + node.attr
+    return ''
+
+
+class Evidence(ast.NodeVisitor):
+    def __init__(self, filename):
+        self.filename = filename
+        self.flow = {}
+        self.items = []
+
+    def kind(self, node):
+        if isinstance(node, ast.Name):
+            return self.flow.get(node.id)
+        if isinstance(node, ast.Call):
+            call = name(node.func)
+            if call in ('open', 'io.open') or call.endswith('.open'):
+                return 'file'
+            if call in ('Path', 'pathlib.Path'):
+                return 'path'
+            if self.reason(node):
+                return 'whole'
+        return None
+
+    def reason(self, node):
+        call = name(node.func)
+        attr = node.func.attr if isinstance(node.func, ast.Attribute) else ''
+        receiver = node.func.value if isinstance(node.func, ast.Attribute) else None
+        if attr in ('read_text', 'read_bytes', 'readlines'):
+            return attr
+        if attr == 'read' and self.kind(receiver) == 'file':
+            size = node.args[0] if node.args else next(
+                (k.value for k in node.keywords if k.arg == 'size'), None)
+            if not (isinstance(size, ast.Constant) and type(size.value) is int and size.value >= 0):
+                return 'unbounded read'
+        if call == 'json.load' and node.args and self.kind(node.args[0]) == 'file':
+            return 'json.load(file)'
+        if call == 'json.loads' and node.args and self.kind(node.args[0]) == 'whole':
+            return 'json.loads(whole-file text)'
+        if call == 'list' and node.args:
+            arg = node.args[0]
+            if self.kind(arg) == 'file' or (isinstance(arg, ast.Call) and name(arg.func) in ('csv.reader', 'csv.DictReader')):
+                return 'materialized file iterator'
+        if call == 'csv.reader' and node.args and isinstance(node.args[0], ast.Call) and name(node.args[0].func) == 'list':
+            return 'csv.reader(list(...))'
+        if call in ('pandas.read_csv', 'pandas.read_json', 'pandas.read_parquet', 'pd.read_csv', 'pd.read_json', 'pd.read_parquet') and not any(k.arg == 'chunksize' for k in node.keywords):
+            return 'whole-frame load'
+        return None
+
+    def visit_Call(self, node):
+        reason = self.reason(node)
+        if reason:
+            self.items.append({'file': self.filename, 'line': node.lineno, 'kind': reason})
+        self.generic_visit(node)
+
+    def visit_Assign(self, node):
+        self.visit(node.value)
+        for target in node.targets:
+            if isinstance(target, ast.Name):
+                self.flow[target.id] = self.kind(node.value)
+
+    def visit_AnnAssign(self, node):
+        if node.value:
+            self.visit(node.value)
+            if isinstance(node.target, ast.Name):
+                self.flow[node.target.id] = self.kind(node.value)
+
+    def visit_With(self, node):
+        for item in node.items:
+            self.visit(item.context_expr)
+            if isinstance(item.optional_vars, ast.Name):
+                self.flow[item.optional_vars.id] = self.kind(item.context_expr)
+        for statement in node.body:
+            self.visit(statement)
+
+    def visit_FunctionDef(self, node):
+        previous = self.flow
+        self.flow = {}
+        for statement in node.body:
+            self.visit(statement)
+        self.flow = previous
+
+    visit_AsyncFunctionDef = visit_FunctionDef
+
+
+def evidence(text, filename='main.py'):
+    visitor = Evidence(filename)
+    visitor.visit(ast.parse(text, filename=filename))
+    return sorted(visitor.items, key=lambda item: (item['line'], item['kind']))
+
+
+def audit(root, ignore=(), fail_on='MEDIUM'):
+    root = Path(root)
+    if not root.is_dir():
+        raise ValueError('audit path must be an existing directory')
+    found = {}
+    production, test_items = [], []
+    source_count = 0
+    for directory, dirs, files in os.walk(root, onerror=lambda error: (_ for _ in ()).throw(error)):
+        dirs[:] = sorted(d for d in dirs if d not in ('.git', '.venv', 'venv', '__pycache__', 'build', 'dist') and not d.startswith('.env') and not (Path(directory) / d).is_symlink())
+        for filename in sorted(files):
+            path = Path(directory) / filename
+            relative = path.relative_to(root)
+            parts = relative.parts
+            if filename.startswith('.env') or path.is_symlink():
+                continue
+            if relative.as_posix() == 'README.md' or (parts[0] == 'docs' and path.suffix == '.md'):
+                for family, claim in claims(path.read_text(encoding='utf-8'), relative.as_posix()).items():
+                    found.setdefault(family, claim)
+            if path.suffix != '.py' or any(p in ('docs', 'examples') for p in parts[:-1]):
+                continue
+            is_test = any(p in ('tests', 'fixtures') for p in parts[:-1]) or filename.startswith('test_') or filename.endswith('_test.py')
+            items = evidence(path.read_text(encoding='utf-8'), relative.as_posix())
+            if is_test:
+                test_items.extend(items)
+            else:
+                source_count += 1
+                production.extend(items)
+    findings, verified = [], []
+    for family, claim in sorted(found.items()):
+        severity = 'HIGH' if production or not source_count else 'MEDIUM'
+        items = production if production else test_items
+        if not source_count or items:
+            rule = RULES[family] + ('-test-only' if severity == 'MEDIUM' else '')
+            if rule not in ignore:
+                findings.append(dict(claim, severity=severity, rule=rule, evidence=items,
+                                     message='No production Python source found.' if not source_count else 'Whole-input loading contradicts documented claim.'))
+        else:
+            verified.append(claim)
+    failed = any(f['severity'] == 'HIGH' or fail_on == 'MEDIUM' for f in findings)
+    return {'findings': findings, 'verified_claims': verified,
+            'summary': {'status': 'FAIL' if failed else 'PASS', 'findings': len(findings),
+                        'high': sum(f['severity'] == 'HIGH' for f in findings),
+                        'medium': sum(f['severity'] == 'MEDIUM' for f in findings)}}

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

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: streaming-claim-audit
+Version: 0.1.0
+Summary: Offline static audit of documented streaming and low-memory claims
+Author: streaming-claim-audit contributors
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# streaming-claim-audit
+
+Version 0.1.0. An offline, stdlib-only CLI that compares documented streaming
+and low-memory promises with static whole-input loading patterns in Python
+source. It never executes audited code, makes network requests, or opens
+`.env` files. No runtime dependencies. Requires Python 3.9 or newer.
+
+## Install and use
+
+```sh
+python3 -m pip install .
+streaming-claim-audit /path/to/project
+python3 -m streaming_claim_audit /path/to/project --json
+streaming-claim-audit --version
+streaming-claim-audit tests/fixtures/testonly --fail-on HIGH
+streaming-claim-audit . --verbose --ignore documented-streaming-claim-false
+```
+
+The path defaults to `.`. Exit codes: **0 PASS**, **2 FAIL**, **1 usage/input
+error**. The default `--fail-on MEDIUM` fails for HIGH or MEDIUM;
+`--fail-on HIGH` still prints MEDIUM findings but allows them to pass.
+`--ignore RULE,...` removes named rules entirely. `--verbose` prints verified
+claims. `--json` emits an object with `findings`, `verified_claims`, and
+`summary`; each finding includes its documentation location and all evidence
+locations. A verified claim means no matching evidence was found, not a proof.
+
+## Scope and rules
+
+Claims come only from root `README.md` and `docs/**/*.md`. Fenced code is
+excluded; inline code counts. Negation suppresses the corresponding family
+within a sentence. Streaming stems include stream, incremental, line-by-line,
+lazy/lazily, iterator-based and yields. Low-memory stems include low memory,
+constant memory, memory efficient, minimal memory and large file variants.
+
+Production source includes recursive `*.py` files except `tests/`, `fixtures/`,
+`docs/`, `examples/`, `test_*.py`, and `*_test.py`. Symlinked files and
+directories are skipped, as are `.git`, `.venv`, `venv`, `__pycache__`, `build`,
+and `dist` directories. Files and directories beginning with `.env` are never
+opened. Invalid source syntax or unreadable inputs produce an input error.
+
+Each family produces at most one finding, carrying every relevant evidence
+item. Production evidence, or claims without production source, yields HIGH:
+
+- `documented-streaming-claim-false`
+- `documented-low-memory-claim-false`
+
+Evidence confined to test/fixture code yields MEDIUM:
+
+- `documented-streaming-claim-false-test-only`
+- `documented-low-memory-claim-false-test-only`
+
+Evidence includes whole-file `read_text`, `read_bytes`, unbounded file `read`,
+`readlines`, file/list and CSV materialization, file-derived JSON loading and
+pandas whole-frame call patterns. Direct file iteration, literal-size chunked
+reads, line iteration with `json.loads(line)`, directly iterated CSV readers,
+and generators do not count. No documented claims means PASS, regardless of
+evidence. There are no reverse rules for undocumented streaming behavior.
+
+## Differentiation
+
+Memory profilers and tracemalloc observe runtime allocations; this tool checks
+documentation promises against source without running the target. Bandit and
+Ruff flag code patterns without relating them to those promises.
+format-claim-audit checks which formats are supported, readonly-claim-audit
+checks writes, and schema-claim-audit checks field names. None checks how much
+input is held in memory. `wc` and file-size tools measure actual input bytes
+rather than comparing documentation with implementation.
+
+## Honest limitations
+
+This is static pattern matching, not semantic judgement or a memory profiler.
+Dead and unreachable code counts. Whole-file configuration reads may be small
+and harmless, and a project may expose both streaming and non-streaming APIs;
+findings require human review. Variable file objects and file-derived text are
+tracked only through simple same-function assignments, not across calls,
+containers or complex control flow. Import aliases are not generally resolved.
+Pandas call-name matching (`pandas` and `pd`) does not verify imports; a
+`chunksize` keyword suppresses it regardless of its value. Chunked-read detection
+recognizes only literal nonnegative integer sizes; computed sizes may be flagged.
+Arbitrary third-party loaders, wrappers, and memory growth outside the listed
+patterns are not detected. Negation and sentence extraction are heuristic,
+not a natural-language understanding system. No evidence is not proof of
+bounded memory. This auditor itself loads source and documentation into memory.
+
+## Development and validation
+
+```sh
+PYTHONPATH=src python3 -m unittest discover -s tests -v
+python3 -m build
+```
+
+The sdist includes tests and fixtures via `MANIFEST.in`. The good fixture
+passes with a verified STREAMING claim. The bad fixture produces exactly two
+HIGH findings. The testonly fixture produces two MEDIUM findings and passes
+only when `--fail-on HIGH` is used (or the relevant rules are ignored).
+
+Licensed under the MIT License; see LICENSE.

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

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

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

@@ -0,0 +1 @@
+

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

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

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

@@ -0,0 +1 @@
+streaming_claim_audit

streaming_claim_audit-0.1.0/tests/fixtures/bad/README.md

@@ -0,0 +1 @@
+This tool provides streaming, constant memory, and handles large files.

streaming_claim_audit-0.1.0/tests/fixtures/bad/main.py

@@ -0,0 +1,11 @@
+import json
+from pathlib import Path
+
+
+def records(path):
+    text = Path(path).read_text(encoding='utf-8')
+    with open(path, encoding='utf-8') as f:
+        data = f.read()
+    with open(path, encoding='utf-8') as f:
+        parsed = json.load(f)
+    return text, data, parsed

streaming_claim_audit-0.1.0/tests/fixtures/good/README.md

@@ -0,0 +1 @@
+This tool streams large JSONL files line by line.

streaming_claim_audit-0.1.0/tests/fixtures/good/main.py

@@ -0,0 +1,7 @@
+import json
+
+
+def records(path):
+    with open(path, encoding='utf-8') as f:
+        for line in f:
+            yield json.loads(line)

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

@@ -0,0 +1 @@
+This tool provides streaming, constant memory, and handles large files.

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

@@ -0,0 +1,4 @@
+def records(path):
+    with open(path, encoding='utf-8') as f:
+        for line in f:
+            yield line

streaming_claim_audit-0.1.0/tests/fixtures/testonly/tests/test_read.py

@@ -0,0 +1,5 @@
+from pathlib import Path
+
+
+def whole_input(path):
+    return Path(path).read_text(encoding='utf-8')

streaming_claim_audit-0.1.0/tests/test_audit.py

@@ -0,0 +1,245 @@
+import json
+import os
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+import unittest
+from unittest.mock import patch
+
+from streaming_claim_audit.audit import audit, claims, evidence, RULES
+
+FIXTURES = Path(__file__).parent / 'fixtures'
+
+
+class ClaimTests(unittest.TestCase):
+    pass
+
+
+CLAIMS = [
+    ('streaming', 'STREAMING'), ('streams', 'STREAMING'),
+    ('stream-based', 'STREAMING'), ('stream processing', 'STREAMING'),
+    ('processes records as a stream', 'STREAMING'),
+    ('reads data incrementally', 'STREAMING'), ('line-by-line', 'STREAMING'),
+    ('line by line', 'STREAMING'), ('lazily', 'STREAMING'),
+    ('lazy loading', 'STREAMING'), ('iterator-based', 'STREAMING'),
+    ('yields records one at a time', 'STREAMING'),
+    ('low-memory', 'LOW_MEMORY'), ('low memory', 'LOW_MEMORY'),
+    ('constant-memory', 'LOW_MEMORY'), ('constant memory', 'LOW_MEMORY'),
+    ('memory-efficient', 'LOW_MEMORY'), ('memory efficient', 'LOW_MEMORY'),
+    ('minimal memory', 'LOW_MEMORY'), ('handles large files', 'LOW_MEMORY'),
+    ('scales to large files', 'LOW_MEMORY'), ('large-file support', 'LOW_MEMORY'),
+    ('STREAMING', 'STREAMING'), ('`streaming`', 'STREAMING'),
+]
+for index, (phrase, family) in enumerate(CLAIMS):
+    def check(self, phrase=phrase, family=family):
+        self.assertIn(family, claims(phrase))
+    setattr(ClaimTests, 'test_claim_%02d' % index, check)
+
+SUPPRESSED = ['not streaming', 'does not stream', 'no streaming support',
+              'not low-memory', 'no constant memory', 'without lazy loading',
+              '```\nstreaming\n```', '~~~md\nlow memory\n~~~',
+              'An ordinary command-line utility.']
+for index, phrase in enumerate(SUPPRESSED):
+    def check(self, phrase=phrase):
+        self.assertEqual(claims(phrase), {})
+    setattr(ClaimTests, 'test_suppression_%02d' % index, check)
+
+
+class EvidenceTests(unittest.TestCase):
+    pass
+
+POSITIVE = [
+    'Path(p).read_text()', 'Path(p).read_bytes()',
+    'f = open(p)\nf.read()', 'f = io.open(p)\nf.read()',
+    'with open(p) as f:\n f.read()',
+    'with Path(p).open() as f:\n f.read()',
+    'f = open(p)\nf.readlines()', 'x.readlines()',
+    'f = open(p)\nlist(f)', 'f = open(p)\njson.load(f)',
+    'f = open(p)\ndata = f.read()\njson.loads(data)',
+    'data = Path(p).read_text()\njson.loads(data)',
+    'csv.reader(list(rows))', 'list(csv.reader(f))',
+    'list(csv.DictReader(f))', 'pandas.read_csv(p)',
+    'pandas.read_json(p)', 'pandas.read_parquet(p)', 'pd.read_csv(p)',
+    'f = open(p)\nf.read().splitlines()',
+    'if False:\n Path(p).read_text()',
+    'f = open(p)\nf.read(-1)', 'f = open(p)\nf.read(size=n)',
+    'f = open(p)\ng = f\ng.read()',
+]
+NEGATIVE = [
+    'with open(p) as f:\n for line in f:\n  print(line)',
+    'with open(p) as f:\n while True:\n  line = f.readline()\n  if not line: break',
+    'f = open(p)\nf.read(4096)', 'f = open(p)\nf.read(size=4096)',
+    'with open(p) as f:\n for line in f:\n  json.loads(line)',
+    'for row in csv.reader(f):\n print(row)',
+    'for row in csv.DictReader(f):\n print(row)',
+    'f = open(p)\niter(f)', 'f = open(p)\n(x for x in f)',
+    'with Path(p).open() as f:\n for line in f:\n  print(line)',
+    'with Path(p).open() as f:\n f.read(4096)',
+    'pandas.read_csv(p, chunksize=100)',
+    'pandas.read_json(p, chunksize=100)',
+    'pandas.read_parquet(p, chunksize=100)',
+    'def parse(text):\n return json.loads(text)',
+    'def a():\n f = open(p)\ndef b():\n f.read()',
+    'f = open(p)\nf = other\nf.read()',
+]
+for positive, snippets in ((True, POSITIVE), (False, NEGATIVE)):
+    for index, source in enumerate(snippets):
+        def check(self, source=source, positive=positive):
+            self.assertEqual(bool(evidence(source)), positive)
+        setattr(EvidenceTests, 'test_%s_%02d' % ('read_all' if positive else 'excluded', index), check)
+
+
+class AuditTests(unittest.TestCase):
+    def project(self, readme='streaming, constant memory', source='for line in open(p):\n print(line)'):
+        temporary = tempfile.TemporaryDirectory()
+        self.addCleanup(temporary.cleanup)
+        root = Path(temporary.name)
+        (root / 'README.md').write_text(readme, encoding='utf-8')
+        if source is not None:
+            (root / 'main.py').write_text(source, encoding='utf-8')
+        return root
+
+    def test_good(self):
+        result = audit(FIXTURES / 'good')
+        self.assertEqual(result['summary']['status'], 'PASS')
+        self.assertIn('STREAMING', [c['family'] for c in result['verified_claims']])
+
+    def test_bad_grouping(self):
+        result = audit(FIXTURES / 'bad')
+        self.assertEqual(result['summary']['high'], 2)
+        for finding in result['findings']:
+            self.assertEqual(len(finding['evidence']), 3)
+            self.assertEqual([i['line'] for i in finding['evidence']], [6, 8, 10])
+
+    def test_testonly(self):
+        result = audit(FIXTURES / 'testonly')
+        self.assertEqual(result['summary']['medium'], 2)
+        self.assertEqual(result['summary']['status'], 'FAIL')
+
+    def test_threshold(self):
+        result = audit(FIXTURES / 'testonly', fail_on='HIGH')
+        self.assertEqual(result['summary']['status'], 'PASS')
+        self.assertEqual(len(result['findings']), 2)
+
+    def test_ignore(self):
+        result = audit(FIXTURES / 'bad', ignore=RULES.values())
+        self.assertEqual(result['findings'], [])
+        self.assertEqual(result['summary']['status'], 'PASS')
+
+    def test_no_claims(self):
+        self.assertEqual(audit(self.project('ordinary utility', 'Path(p).read_text()'))['summary']['status'], 'PASS')
+
+    def test_no_source(self):
+        result = audit(self.project(source=None))
+        self.assertEqual(result['summary']['high'], 2)
+        self.assertTrue(all(not f['evidence'] for f in result['findings']))
+
+    def test_docs_nested(self):
+        root = self.project('ordinary utility', 'Path(p).read_text()')
+        (root / 'docs' / 'nested').mkdir(parents=True)
+        (root / 'docs' / 'nested' / 'guide.md').write_text('streaming', encoding='utf-8')
+        self.assertEqual(audit(root)['summary']['high'], 1)
+
+    def test_other_markdown_ignored(self):
+        root = self.project('ordinary utility')
+        (root / 'OTHER.md').write_text('streaming', encoding='utf-8')
+        self.assertEqual(audit(root)['verified_claims'], [])
+
+    def test_symlink(self):
+        root = self.project()
+        (root / 'linked.py').symlink_to(FIXTURES / 'bad' / 'main.py')
+        (root / 'linked').symlink_to(FIXTURES / 'bad', target_is_directory=True)
+        self.assertEqual(audit(root)['summary']['status'], 'PASS')
+
+    def test_unreadable_root(self):
+        with patch('streaming_claim_audit.audit.os.walk', side_effect=PermissionError('denied')):
+            with self.assertRaises(PermissionError):
+                audit(self.project())
+
+    def test_invalid_syntax(self):
+        with self.assertRaises(SyntaxError):
+            audit(self.project(source='def !'))
+
+    def test_family_specific_negation(self):
+        self.assertEqual(set(claims('Not streaming but constant memory.')), {'LOW_MEMORY'})
+
+    def test_separate_sentences(self):
+        self.assertIn('STREAMING', claims('Not streaming. Another API streams data.'))
+
+    def test_fence_location(self):
+        self.assertEqual(claims('```\nstreaming\n```\nStreams data.')['STREAMING']['line'], 4)
+
+    def test_function_flow(self):
+        items = evidence('def load(p):\n with open(p) as f:\n  data = f.read()\n  return json.loads(data)')
+        self.assertEqual(len(items), 2)
+
+
+for index, location in enumerate(('tests/helper.py', 'fixtures/helper.py', 'test_helper.py', 'helper_test.py', 'docs/helper.py', 'examples/helper.py')):
+    def check(self, location=location):
+        root = self.project()
+        path = root / location
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text('Path(p).read_text()', encoding='utf-8')
+        result = audit(root)
+        self.assertEqual(result['summary']['high'], 0)
+        self.assertEqual(result['summary']['medium'], 0 if location.startswith(('docs/', 'examples/')) else 2)
+    setattr(AuditTests, 'test_source_exclusion_%02d' % index, check)
+
+
+class CLITests(unittest.TestCase):
+    def run_cli(self, *args, **kwargs):
+        return subprocess.run([sys.executable, '-m', 'streaming_claim_audit', *map(str, args)], capture_output=True, text=True, **kwargs)
+
+    def test_good(self):
+        run = self.run_cli(FIXTURES / 'good')
+        self.assertEqual(run.returncode, 0)
+        self.assertEqual(run.stdout.strip(), 'PASS')
+
+    def test_bad_json(self):
+        run = self.run_cli(FIXTURES / 'bad', '--json')
+        self.assertEqual(run.returncode, 2)
+        result = json.loads(run.stdout)
+        self.assertEqual(set(result), {'findings', 'verified_claims', 'summary'})
+        self.assertEqual(result['summary']['high'], 2)
+
+    def test_testonly_default(self):
+        run = self.run_cli(FIXTURES / 'testonly')
+        self.assertEqual(run.returncode, 2)
+        self.assertEqual(run.stdout.count('MEDIUM '), 2)
+
+    def test_testonly_high(self):
+        run = self.run_cli(FIXTURES / 'testonly', '--fail-on', 'HIGH')
+        self.assertEqual(run.returncode, 0)
+        self.assertEqual(run.stdout.count('MEDIUM '), 2)
+
+    def test_version(self):
+        run = self.run_cli('--version')
+        self.assertEqual((run.returncode, run.stdout.strip()), (0, '0.1.0'))
+
+    def test_bad_path(self):
+        self.assertEqual(self.run_cli(FIXTURES / 'missing').returncode, 1)
+
+    def test_bad_option(self):
+        self.assertEqual(self.run_cli('--unknown').returncode, 1)
+
+    def test_bad_threshold(self):
+        self.assertEqual(self.run_cli('--fail-on', 'LOW').returncode, 1)
+
+    def test_ignore_cli(self):
+        run = self.run_cli(FIXTURES / 'bad', '--ignore', ','.join(RULES.values()))
+        self.assertEqual((run.returncode, run.stdout.strip()), (0, 'PASS'))
+
+    def test_verbose(self):
+        self.assertIn('VERIFIED STREAMING', self.run_cli(FIXTURES / 'good', '--verbose').stdout)
+
+    def test_json_verified(self):
+        self.assertEqual(len(json.loads(self.run_cli(FIXTURES / 'good', '--json').stdout)['verified_claims']), 1)
+
+    def test_default_path(self):
+        env = dict(os.environ, PYTHONPATH=str(Path(__file__).resolve().parents[1] / 'src'))
+        self.assertEqual(self.run_cli(cwd=FIXTURES / 'good', env=env).returncode, 0)
+
+
+if __name__ == '__main__':
+    unittest.main()