openpub 0.1.0__py3-none-any.whl

openpub/__init__.py

@@ -0,0 +1,3 @@
+from openpub.registry import claim
+
+__all__ = ["claim"]

openpub/__main__.py

@@ -0,0 +1,3 @@
+from openpub.cli import cli
+
+cli()

openpub/cli.py

@@ -0,0 +1,28 @@
+import click
+
+from openpub.init_cmd import run_init
+from openpub.verify_cmd import run_verify
+
+
+@click.group()
+def cli():
+    """openpub — verify scientific paper claims with code."""
+    pass
+
+
+@cli.command()
+@click.argument("claims_json", type=click.Path(exists=True))
+@click.option("-o", "--output", default=".", help="Output directory for scaffolded project.")
+def init(claims_json, output):
+    """Scaffold a paper verification project from a claims JSON file."""
+    run_init(claims_json, output)
+    click.echo(f"Scaffolded project in {output}")
+
+
+@cli.command()
+@click.option("--claims", default="./claims.json", help="Path to claims JSON file.")
+@click.option("--dir", "directory", default=".", help="Directory to scan for .py files.")
+def verify(claims, directory):
+    """Run @claim-decorated functions and compare results against expected values."""
+    exit_code = run_verify(claims, directory)
+    raise SystemExit(exit_code)

openpub/comparison.py

@@ -0,0 +1,61 @@
+from typing import Any
+
+
+def compare_values(expected: Any, actual: Any, path: str = "") -> list[str]:
+    """Compare expected and actual values, returning a list of failure messages.
+
+    Handles:
+    - {"value": X, "tolerance": Y} dicts -> tolerance-based numeric comparison
+    - Plain int -> exact match (type-strict)
+    - Plain float -> near-exact (relative epsilon 1e-9)
+    - str -> exact match
+    - Nested dict -> recursive comparison
+    - Missing keys -> failure; extra keys -> informational, not failure
+    """
+    failures = []
+
+    if isinstance(expected, dict) and "value" in expected and "tolerance" in expected:
+        # Tolerance-based comparison
+        if not isinstance(actual, (int, float)):
+            failures.append(f"{path}: expected numeric value, got {type(actual).__name__}")
+            return failures
+        exp_val = expected["value"]
+        tol = expected["tolerance"]
+        if abs(actual - exp_val) > tol:
+            failures.append(
+                f"{path}: {actual} != {exp_val} (tolerance {tol}, diff {abs(actual - exp_val):.6g})"
+            )
+    elif isinstance(expected, dict):
+        # Nested dict -> recursive comparison
+        if not isinstance(actual, dict):
+            failures.append(f"{path}: expected dict, got {type(actual).__name__}")
+            return failures
+        for key in expected:
+            child_path = f"{path}.{key}" if path else key
+            if key not in actual:
+                failures.append(f"{child_path}: missing key")
+            else:
+                failures.extend(compare_values(expected[key], actual[key], child_path))
+    elif isinstance(expected, int) and not isinstance(expected, bool):
+        # Exact integer match (type-strict)
+        if not isinstance(actual, int) or isinstance(actual, bool):
+            failures.append(f"{path}: expected int, got {type(actual).__name__} ({actual!r})")
+        elif actual != expected:
+            failures.append(f"{path}: {actual} != {expected}")
+    elif isinstance(expected, float):
+        # Near-exact float match
+        if not isinstance(actual, (int, float)):
+            failures.append(f"{path}: expected numeric, got {type(actual).__name__}")
+        elif expected == 0.0:
+            if abs(actual) > 1e-9:
+                failures.append(f"{path}: {actual} != {expected}")
+        elif abs(actual - expected) / max(abs(expected), 1e-15) > 1e-9:
+            failures.append(f"{path}: {actual} != {expected}")
+    elif isinstance(expected, str):
+        if actual != expected:
+            failures.append(f"{path}: {actual!r} != {expected!r}")
+    else:
+        if actual != expected:
+            failures.append(f"{path}: {actual!r} != {expected!r}")
+
+    return failures

openpub/init_cmd.py

@@ -0,0 +1,136 @@
+import json
+import shutil
+from pathlib import Path
+from typing import Any
+
+
+def _make_function_name(claim_id: str) -> str:
+    """Convert claim ID like 'C5' to function name like 'verify_c5'."""
+    return f"verify_{claim_id.lower()}"
+
+
+def _format_return_value(expected: dict[str, Any], indent: int = 1) -> str:
+    """Format expected values as a Python return dict literal."""
+    lines = []
+    prefix = "    " * indent
+    lines.append("{")
+    items = list(expected.items())
+    for i, (key, val) in enumerate(items):
+        comma = "," if i < len(items) - 1 else ","
+        if isinstance(val, dict) and "value" in val and "tolerance" in val:
+            # Tolerance value: emit the scalar with a tolerance comment
+            lines.append(f'{prefix}    "{key}": {_format_scalar(val["value"])},{comma[:-1]}  # tolerance: {val["tolerance"]}')
+        elif isinstance(val, dict):
+            # Nested dict
+            nested = _format_return_value(val, indent + 1)
+            lines.append(f'{prefix}    "{key}": {nested}{comma}')
+        else:
+            lines.append(f'{prefix}    "{key}": {_format_scalar(val)}{comma}')
+    lines.append(f"{prefix}}}")
+    return "\n".join(lines)
+
+
+def _format_scalar(val: Any) -> str:
+    """Format a scalar value as a Python literal."""
+    if isinstance(val, str):
+        return repr(val)
+    if isinstance(val, bool):
+        return repr(val)
+    if isinstance(val, int):
+        return str(val)
+    if isinstance(val, float):
+        return repr(val)
+    return repr(val)
+
+
+def generate_analysis_py(claims: list[dict]) -> str:
+    """Generate analysis.py content with stub functions for claims with expected values."""
+    lines = ['from openpub import claim', '', '']
+
+    claims_with_expected = [c for c in claims if "expected" in c]
+
+    for i, c in enumerate(claims_with_expected):
+        claim_id = c["claim_id"]
+        fn_name = _make_function_name(claim_id)
+        expected = c["expected"]
+
+        lines.append(f'@claim("{claim_id}")')
+        lines.append(f'def {fn_name}():')
+        lines.append(f'    """Verify: {c["claim"][:80]}"""')
+
+        return_dict = _format_return_value(expected)
+        lines.append(f'    return {return_dict}')
+
+        if i < len(claims_with_expected) - 1:
+            lines.append('')
+            lines.append('')
+
+    lines.append('')
+    return "\n".join(lines)
+
+
+def generate_pyproject_toml() -> str:
+    """Generate a minimal pyproject.toml for the scaffolded project."""
+    return '''[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "my-paper"
+version = "0.1.0"
+requires-python = ">=3.10"
+dependencies = [
+    "openpub",
+]
+'''
+
+
+def generate_readme(claims: list[dict]) -> str:
+    """Generate a README.md for the scaffolded project."""
+    total = len(claims)
+    with_expected = sum(1 for c in claims if "expected" in c)
+    return f"""# Paper Verification
+
+This project uses [openpub](https://pypi.org/project/openpub/) to verify scientific claims.
+
+- **Total claims**: {total}
+- **Verifiable claims** (with expected values): {with_expected}
+
+## Quick Start
+
+```bash
+# Install dependencies
+uv pip install -e .
+
+# Run verification
+openpub verify
+```
+
+## Files
+
+- `claims.json` — Structured claims extracted from the paper
+- `analysis.py` — Verification functions decorated with `@claim`
+"""
+
+
+def run_init(claims_path: str, output_dir: str) -> None:
+    """Scaffold a paper verification project from a claims JSON file."""
+    claims_file = Path(claims_path)
+    if not claims_file.exists():
+        raise FileNotFoundError(f"Claims file not found: {claims_path}")
+
+    claims = json.loads(claims_file.read_text())
+    out = Path(output_dir)
+    out.mkdir(parents=True, exist_ok=True)
+
+    # analysis.py
+    (out / "analysis.py").write_text(generate_analysis_py(claims))
+
+    # pyproject.toml
+    (out / "pyproject.toml").write_text(generate_pyproject_toml())
+
+    # README.md
+    (out / "README.md").write_text(generate_readme(claims))
+
+    # claims.json (copy verbatim)
+    shutil.copy2(claims_file, out / "claims.json")

openpub/registry.py

@@ -0,0 +1,33 @@
+from collections.abc import Callable
+from typing import Any
+
+_registry: dict[str, Callable[[], Any]] = {}
+
+
+def claim(claim_id: str) -> Callable:
+    """Decorator that registers a function as the verifier for a claim ID.
+
+    Usage:
+        @claim("C5")
+        def verify_c5():
+            return {"n_with_recurrent_variant": 89, ...}
+    """
+    def decorator(fn: Callable[[], Any]) -> Callable[[], Any]:
+        if claim_id in _registry:
+            raise ValueError(
+                f"Duplicate claim ID {claim_id!r}: "
+                f"already registered to {_registry[claim_id].__name__!r}"
+            )
+        _registry[claim_id] = fn
+        return fn
+    return decorator
+
+
+def get_registry() -> dict[str, Callable[[], Any]]:
+    """Return a copy of the current claim registry."""
+    return dict(_registry)
+
+
+def clear_registry() -> None:
+    """Clear all registered claims. Used for testing."""
+    _registry.clear()

openpub/verify_cmd.py

@@ -0,0 +1,143 @@
+import importlib.util
+import json
+import sys
+from pathlib import Path
+
+import click
+
+from openpub.comparison import compare_values
+from openpub.registry import clear_registry, get_registry
+
+
+def _discover_modules(directory: Path) -> list[Path]:
+    """Find all .py files in the directory, excluding _-prefixed files."""
+    return sorted(
+        p for p in directory.glob("*.py")
+        if not p.name.startswith("_")
+    )
+
+
+def _import_module_from_path(path: Path) -> None:
+    """Import a Python module from a file path, triggering @claim registrations."""
+    module_name = path.stem
+    spec = importlib.util.spec_from_file_location(module_name, path)
+    if spec is None or spec.loader is None:
+        return
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[module_name] = module
+    spec.loader.exec_module(module)
+
+
+def run_verify(claims_path: str, directory: str) -> int:
+    """Run verification of claims. Returns exit code (0 = success, 1 = failures)."""
+    claims_file = Path(claims_path)
+    if not claims_file.exists():
+        click.secho(f"Error: claims file not found: {claims_path}", fg="red")
+        return 1
+
+    claims = json.loads(claims_file.read_text())
+    claims_with_expected = {c["claim_id"]: c for c in claims if "expected" in c}
+
+    # Clear registry and discover modules
+    clear_registry()
+    cwd = Path(directory)
+    for py_file in _discover_modules(cwd):
+        try:
+            _import_module_from_path(py_file)
+        except Exception as e:
+            click.secho(f"Warning: failed to import {py_file.name}: {e}", fg="yellow")
+
+    registry = get_registry()
+
+    verified = []
+    failed = []
+    errors = []
+    open_claims = []
+
+    for claim_id, claim_data in sorted(claims_with_expected.items(), key=lambda x: _sort_key(x[0])):
+        expected = claim_data["expected"]
+
+        if claim_id not in registry:
+            open_claims.append(claim_id)
+            continue
+
+        fn = registry[claim_id]
+        try:
+            result = fn()
+        except Exception as e:
+            errors.append((claim_id, str(e)))
+            continue
+
+        if not isinstance(result, dict):
+            errors.append((claim_id, f"returned {type(result).__name__}, expected dict"))
+            continue
+
+        failures = compare_values(expected, result)
+        if failures:
+            failed.append((claim_id, failures))
+        else:
+            verified.append(claim_id)
+
+    # Report results
+    _print_results(verified, failed, errors, open_claims, len(claims_with_expected))
+
+    if failed or errors:
+        return 1
+    return 0
+
+
+def _sort_key(claim_id: str) -> tuple[str, int]:
+    """Sort claim IDs like C1, C2, ..., C10 numerically."""
+    prefix = ""
+    num = 0
+    for i, ch in enumerate(claim_id):
+        if ch.isdigit():
+            prefix = claim_id[:i]
+            num = int(claim_id[i:])
+            break
+    return (prefix, num)
+
+
+def _print_results(
+    verified: list[str],
+    failed: list[tuple[str, list[str]]],
+    errors: list[tuple[str, str]],
+    open_claims: list[str],
+    total: int,
+) -> None:
+    """Print colored verification results."""
+    click.echo()
+
+    if verified:
+        click.secho(f"  VERIFIED ({len(verified)})", fg="green", bold=True)
+        for cid in verified:
+            click.secho(f"    {cid}", fg="green")
+
+    if failed:
+        click.echo()
+        click.secho(f"  FAILED ({len(failed)})", fg="red", bold=True)
+        for cid, failures in failed:
+            click.secho(f"    {cid}:", fg="red")
+            for f in failures:
+                click.secho(f"      {f}", fg="red")
+
+    if errors:
+        click.echo()
+        click.secho(f"  ERRORS ({len(errors)})", fg="yellow", bold=True)
+        for cid, msg in errors:
+            click.secho(f"    {cid}: {msg}", fg="yellow")
+
+    if open_claims:
+        click.echo()
+        click.secho(f"  OPEN ({len(open_claims)})", fg="cyan", bold=True)
+        for cid in open_claims:
+            click.secho(f"    {cid}", fg="cyan")
+
+    click.echo()
+    click.echo(
+        f"  {len(verified)}/{total} verified, "
+        f"{len(failed)} failed, "
+        f"{len(errors)} errors, "
+        f"{len(open_claims)} open"
+    )
+    click.echo()

openpub-0.1.0.dist-info/METADATA

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: openpub
+Version: 0.1.0
+Summary: Verify scientific paper claims with code
+Requires-Python: >=3.10
+Requires-Dist: click>=8.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == 'dev'

openpub-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+openpub/__init__.py,sha256=b2lq9sf5VH4QjyuOL1Nkiv1EiDIl5kmMGUJpPY-ZOas,56
+openpub/__main__.py,sha256=qTfPt9xr4yBzISFsza4kta6SsFeNqYdB9oUnfWVTp8U,35
+openpub/cli.py,sha256=AsOMS2lgiK5PvYda4OxEadNJt7lP6O76RcWRHPv11ok,942
+openpub/comparison.py,sha256=Fw-Tlkse3qnj74rkHGbD9KZejSt0nj159xfnJaOkN8s,2726
+openpub/init_cmd.py,sha256=bUfV99mEutAJBJzZZzKu8rRWJzJMXRQtJDuVvibPbOA,4070
+openpub/registry.py,sha256=sJcweF58ao2qB8He2xc0hc_IwS9YBTJozAP6uxtZjtw,931
+openpub/verify_cmd.py,sha256=IuipKvHjRicux3KCLhEl-HYrLgxHhYtEiem4X53vkog,4208
+openpub-0.1.0.dist-info/METADATA,sha256=kXkEb8KRMRFhsETeocKOKPrRArAqArfCDnkfHgrQg3I,214
+openpub-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+openpub-0.1.0.dist-info/entry_points.txt,sha256=q4kJbzVf4TwBMjAVlaHXBryRnnlf_FhUF9qKlT-kEoY,44
+openpub-0.1.0.dist-info/RECORD,,

openpub-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

openpub-0.1.0.dist-info/entry_points.txt

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