hoodscript 1.3.0__tar.gz → 1.3.1__tar.gz

{hoodscript-1.3.0 → hoodscript-1.3.1}/CHANGELOG.md

@@ -5,6 +5,31 @@ Versioning: the keyword set is the public API; changing it is at least a minor b
 
 ## [Unreleased]
 
+## [1.3.1] — 2026-09-12
+
+Patch release: what the fresh-machine check of 1.3.0 found, plus two audit
+leftovers. No keyword or API changes.
+
+### Fixed
+
+- Fresh-machine check of v1.3.0 (`pip install "hoodscript[all]"` in a clean
+  venv, `docs/onboarding.md` §2–§11 verbatim): everything passed except
+  `hoodfarm test` and `hoodarcade test`, which reported "No Sol" for every
+  level and **exited 0** — the reference solutions were not in the wheel and a
+  missing solution counted as a pass. The solutions now ship
+  (`hoodscript/data/solutions`, found by both CLIs after the repo checkout), a
+  missing one is a red `MISSING` row and a non-zero exit, and
+  `tests/test_wheel_contents.py` builds the wheel and asserts the runtime
+  data (curriculum, `vibe.py`, solutions) is inside it.
+
+- `hoodscript --sandbox run f.hs` now works (the flags may come before or after
+  `run`; `run` is recognised as the first positional, not only as `argv[0]`).
+- Jupyter: `%hood_tb` is honoured by the error card — the Python traceback
+  section opens by default and the plain-text fallback carries it too.
+- MANUAL §16 documents that `hoodscript fmt` writes `ain't nobody x` back as
+  `ain't x` (same Python, one canonical spelling).
+- `cli.py` had the `arcade` dispatch block twice; the copy is gone.
+
 ## [1.3.0] — 2026-09-12
 
 Three features that were on `main` but not on PyPI: the two games and the

{hoodscript-1.3.0 → hoodscript-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hoodscript
-Version: 1.3.0
+Version: 1.3.1
 Summary: A production-grade Python 3 conlang based on AAVE with 1:1 AST parity.
 License: MIT
 License-File: LICENSE

{hoodscript-1.3.0 → hoodscript-1.3.1}/pyproject.toml

@@ -61,6 +61,9 @@ packages = ["src/hoodscript", "src/hoodlib", "src/hoodfarm", "src/hoodarcade"]
 "docs/curriculum.md" = "hoodscript/data/curriculum.md"
 # `import vibe` — the Zen of HoodScript, like `import this`.
 "src/vibe.py" = "vibe.py"
+# `hoodfarm test` / `hoodarcade test` benchmark the reference solutions; a pip
+# install has no examples/ tree, so ship them (found via hoodscript/data/solutions).
+"examples/solutions" = "hoodscript/data/solutions"
 
 [tool.hatch.build.targets.sdist]
 # The nested hoodscript/ prototype is reference material, not part of the distribution.

{hoodscript-1.3.0 → hoodscript-1.3.1}/src/hoodarcade/cli.py

@@ -191,11 +191,23 @@ def cmd_run(args: argparse.Namespace, console: Console, ui: ArcadeUI, progress:
     return run_stage_session(game_id, stage_id, file_path, console, ui, progress, once=True)
 
 
+def solutions_dir() -> Path:
+    """Where the reference solutions live: the repo's examples/solutions when run
+    from a checkout, else the copy shipped in the wheel (hoodscript/data/solutions)."""
+    import hoodscript
+    for cand in (
+        Path("examples/solutions"),
+        Path(__file__).resolve().parents[2] / "examples" / "solutions",
+        Path(hoodscript.__file__).resolve().parent / "data" / "solutions",
+    ):
+        if cand.is_dir():
+            return cand
+    return Path("examples/solutions")
+
+
 def cmd_test(args: argparse.Namespace, console: Console) -> int:
     """Run automated benchmarks against reference solutions."""
-    solutions_root = Path("examples/solutions")
-    if not solutions_root.exists():
-        solutions_root = Path(__file__).resolve().parents[2] / "examples" / "solutions"
+    solutions_root = solutions_dir()
 
     target_games = [args.game.lower()] if args.game else list(GAMES_MAP.keys())
     failures = 0
@@ -220,12 +232,13 @@ def cmd_test(args: argparse.Namespace, console: Console) -> int:
             sol_file = solutions_root / game_id / f"stage{stg_id}.hs"
 
             if not sol_file.exists():
+                failures += 1                                 # a missing solution is not a pass
                 table.add_row(
                     game_id.capitalize(),
                     str(stg_id),
                     stage.title,
                     ", ".join(stage.concepts),
-                    "[dim]No Sol[/dim]",
+                    f"[bold red]MISSING[/bold red] {sol_file}",
                 )
                 continue
 

{hoodscript-1.3.0 → hoodscript-1.3.1}/src/hoodfarm/cli.py

@@ -128,11 +128,23 @@ def cmd_run(args: argparse.Namespace, console: Console) -> int:
     return 0 if won else 1
 
 
+def solutions_dir() -> Path:
+    """Where the reference solutions live: the repo's examples/solutions when run
+    from a checkout, else the copy shipped in the wheel (hoodscript/data/solutions)."""
+    import hoodscript
+    for cand in (
+        Path("examples/solutions"),
+        Path(__file__).resolve().parents[2] / "examples" / "solutions",
+        Path(hoodscript.__file__).resolve().parent / "data" / "solutions",
+    ):
+        if cand.is_dir():
+            return cand
+    return Path("examples/solutions")
+
+
 def cmd_test(args: argparse.Namespace, console: Console) -> int:
     """Run automated benchmarks against solutions."""
-    solutions_dir = Path("examples/solutions")
-    if not solutions_dir.exists():
-        solutions_dir = Path(__file__).resolve().parents[2] / "examples" / "solutions"
+    solutions = solutions_dir()
 
     target_levels = [args.level] if args.level else sorted(ALL_LEVELS.keys())
     failures = 0
@@ -152,9 +164,10 @@ def cmd_test(args: argparse.Namespace, console: Console) -> int:
 
     for lvl_id in target_levels:
         level = ALL_LEVELS[lvl_id]
-        sol_file = solutions_dir / f"level{lvl_id}.hs"
+        sol_file = solutions / f"level{lvl_id}.hs"
         if not sol_file.exists():
-            table.add_row(str(lvl_id), level.title, "-", "-", "-", "[dim]No Sol[/dim]")
+            failures += 1                                     # a missing solution is not a pass
+            table.add_row(str(lvl_id), level.title, "-", "-", "-", f"[bold red]MISSING[/bold red] {sol_file}")
             continue
 
         code = sol_file.read_text(encoding="utf-8")

{hoodscript-1.3.0 → hoodscript-1.3.1}/src/hoodscript/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.3.0'
-__version_tuple__ = version_tuple = (1, 3, 0)
+__version__ = version = '1.3.1'
+__version_tuple__ = version_tuple = (1, 3, 1)
 
 __commit_id__ = commit_id = None

{hoodscript-1.3.0 → hoodscript-1.3.1}/src/hoodscript/cli.py

@@ -380,6 +380,20 @@ def kernel_command(args: list[str]) -> int:
     return 0
 
 
+_VALUED = ("--max-seconds", "--max-output", "--max-depth")
+
+
+def _strip_run(argv):
+    i = 0
+    while i < len(argv):
+        a = argv[i]
+        if a in _VALUED: i += 2; continue
+        if a.startswith("-") and a != "-": i += 1; continue
+        if a == "run": return argv[:i] + argv[i + 1:]
+        return argv
+    return argv
+
+
 def main(argv=None) -> int:
     if argv is None:
         argv = sys.argv[1:]
@@ -449,13 +463,6 @@ def main(argv=None) -> int:
             sys.stderr.write("The arcade needs rich. Install it: pip install \"hoodscript[arcade]\"\n")
             return 2
         return arcade_main(argv[1:])
-    if cmd == "arcade":
-        try:
-            from hoodarcade.cli import main as arcade_main
-        except ImportError:
-            sys.stderr.write("The arcade needs rich. Install it: pip install \"hoodscript[arcade]\"\n")
-            return 2
-        return arcade_main(argv[1:])
     if cmd == "build":
         # build <file> transpiles to stdout (alias for -c)
         if len(argv) < 2:
@@ -467,9 +474,10 @@ def main(argv=None) -> int:
         sys.stdout.write(transpile(src, filepath) + "\n")
         return 0
 
-    # If user ran `hoodscript run ...`
-    if cmd == "run":
-        argv = argv[1:]
+    # `hoodscript run f.hs` and `hoodscript --sandbox run f.hs` both work: `run` is
+    # the first positional, wherever the flags landed. `_VALUED` are the options
+    # that take an argument, so their value is not mistaken for the positional.
+    argv = _strip_run(argv)
 
     # Fallback to standard execution parser (supports `hoodscript <file>`, `-c`, `--sandbox`, etc.)
     parser = argparse.ArgumentParser(prog="hoodscript")

{hoodscript-1.3.0 → hoodscript-1.3.1}/src/hoodscript/kernel/kernel.py

@@ -109,8 +109,9 @@ class HoodScriptKernel(Kernel):
             )
 
         if raw_tb_escaped:
+            opened = " open" if self.show_raw_traceback else ""   # %hood_tb expands the traceback by default
             card += f"""
-                <details style="margin-top: 8px; font-size: 12px; color: #9ca3af;">
+                <details{opened} style="margin-top: 8px; font-size: 12px; color: #9ca3af;">
                     <summary style="cursor: pointer; user-select: none;">Show Python Traceback</summary>
                     <pre style="background: rgba(0,0,0,0.4); padding: 8px; border-radius: 4px;
                                color: #f87171; overflow-x: auto; font-family: monospace;
@@ -126,6 +127,8 @@ class HoodScriptKernel(Kernel):
             return
 
         plain_text = render_plain(diag) if diag else str(exc)
+        if self.show_raw_traceback and raw_tb:
+            plain_text += "\n\n--- Python traceback (%hood_tb) ---\n" + raw_tb
         html_card = self._render_html_card(diag, raw_tb)
 
         content = {

{hoodscript-1.3.0 → hoodscript-1.3.1}/tests/test_cli.py

@@ -86,6 +86,20 @@ def test_cli_run(tmp_path):
     assert "from run" in res2.stdout.strip()
 
 
+def test_cli_run_accepts_flags_before_the_word_run(tmp_path):
+    """`hoodscript --sandbox run f.hs` and `hoodscript run --sandbox f.hs` are the same command."""
+    from hoodscript.cli import _strip_run
+    assert _strip_run(["run", "f.hs"]) == ["f.hs"]
+    assert _strip_run(["--sandbox", "run", "f.hs"]) == ["--sandbox", "f.hs"]
+    assert _strip_run(["--max-seconds", "5", "run", "f.hs"]) == ["--max-seconds", "5", "f.hs"]
+    assert _strip_run(["run.hs"]) == ["run.hs"]                # a file called run.hs is a file
+    assert _strip_run(["f.hs", "run"]) == ["f.hs", "run"]      # only the first positional
+    src = tmp_path / "prog.hs"
+    src.write_text('f = open("/dev/null")\n', encoding="utf-8")
+    res = run_cli("--sandbox", "run", str(src))
+    assert res.returncode != 0 and "NoAccessTrip" in res.stderr
+
+
 def test_cli_fmt_and_lint(tmp_path):
     src = tmp_path / "test.hs"
     src.write_text("bet f( ):\n    unused = 1\n    dip 2\n", encoding="utf-8")

{hoodscript-1.3.0 → hoodscript-1.3.1}/tests/test_kernel.py

@@ -105,6 +105,20 @@ def test_kernel_magic_traceback_toggle(mock_kernel):
     res = mock_kernel.do_execute("%hood_tb", silent=False)
     assert res["status"] == "ok"
     assert mock_kernel.show_raw_traceback is True
+    # The toggle is honoured by the card: the traceback section opens by default
+    # and the plain-text fallback carries the raw traceback too.
+    mock_kernel.send_response.reset_mock()
+    mock_kernel.do_execute("throw BadValueTrip('x')", silent=False)
+    shown = [c for c in mock_kernel.send_response.call_args_list if c.args[1] == "display_data"]
+    assert shown, "no diagnostic was displayed"
+    data = shown[-1].args[2]["data"]
+    assert "<details open" in data["text/html"]
+    assert "--- Python traceback (%hood_tb) ---" in data["text/plain"]
+    mock_kernel.do_execute("%hood_tb", silent=False)           # back off
+    mock_kernel.send_response.reset_mock()
+    mock_kernel.do_execute("throw BadValueTrip('x')", silent=False)
+    shown = [c for c in mock_kernel.send_response.call_args_list if c.args[1] == "display_data"]
+    assert "<details open" not in shown[-1].args[2]["data"]["text/html"]
 
 
 def test_kernel_do_complete(mock_kernel):

hoodscript-1.3.1/tests/test_wheel_contents.py

@@ -0,0 +1,34 @@
+"""The wheel is what users install; the repo is what tests run against. Things the
+CLI reads at runtime (curriculum, `import vibe`, the games' reference solutions)
+are force-included by pyproject — this test builds the wheel and checks they are
+in it, because a fresh-machine check of v1.3.0 found `hoodfarm test` reporting
+"No Sol" for every level and exiting 0."""
+
+import subprocess
+import sys
+import zipfile
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[1]
+pytest.importorskip("hatchling")
+
+REQUIRED = [
+    "hoodscript/data/curriculum.md",
+    "vibe.py",
+    "hoodscript/data/solutions/level1.hs",
+    "hoodscript/data/solutions/level8.hs",
+    "hoodscript/data/solutions/cookout/stage1.hs",
+    "hoodscript/data/solutions/beatlab/stage5.hs",
+    "hoodscript/data/solutions/dropday/stage3.hs",
+]
+
+
+def test_wheel_ships_the_runtime_data(tmp_path):
+    subprocess.run([sys.executable, "-m", "hatchling", "build", "-t", "wheel", "-d", str(tmp_path)],
+                   cwd=ROOT, check=True, capture_output=True)
+    wheel = next(tmp_path.glob("*.whl"))
+    names = set(zipfile.ZipFile(wheel).namelist())
+    missing = [n for n in REQUIRED if n not in names]
+    assert not missing, f"not in the wheel: {missing}"