From 571f005ee8dddf2bb0e41a86f1a9d7697a439c9e Mon Sep 17 00:00:00 2001 From: Sean Stoube <31805425+HoneyBearTech@users.noreply.github.com> Date: Fri, 20 Nov 2026 11:47:11 +0000 Subject: [PATCH 1/3] docs: plan for classdef-finally Signed-off-by: Sean Stoube <31805425+HoneyBearTech@users.noreply.github.com> --- docs/plans/classdef-finally.md | 37 ++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) create mode 100644 docs/plans/classdef-finally.md diff --git a/docs/plans/classdef-finally.md b/docs/plans/classdef-finally.md new file mode 100644 index 0000000..efad7a0 --- /dev/null +++ b/docs/plans/classdef-finally.md @@ -0,0 +1,37 @@ +# Plan: classdef-finally + +## What Sean asked for +"start on the class body try/finally fix": the small follow-up found while working on #902. + +## What we found +- When a class body raises an error, pyscript never leaves the class's scope (`ast_classdef` in `custom_components/pyscript/eval.py`). It switches into the class's namespace before running the body and switches back only after the body finishes normally. +- Checked on upstream's latest code: with `try: class Foo: raise ValueError ... except ValueError: pass` at the top of a script, a later `x = 5` is stored inside the failed class, not in the script. Real Python stores it in the script. +- Inside a function, the same error leaves pyscript's internal scope stack one entry too long. Upstream issue search found no existing report. +- #902's second commit (not merged yet) changes the same few lines. Whichever PR merges second needs a small, mechanical update. + +## What we'll change +1. **`custom_components/pyscript/eval.py`, `ast_classdef`:** wrap the loop that runs the class body in `try`/`finally`, so pyscript always returns to the outer scope, even when the body raises. *Check:* new tests below. +2. **Tests in `tests/test_unit_eval.py`**, each checked against real Python: + - a class body that raises, caught by `try`/`except` at module level, then later assignments land in the script; + - the same inside a function, with the function's later locals and return value correct; + - a nested class whose body raises; + - an error from a class body that isn't caught: it still reaches the caller, and the next script run is unaffected. + *Check:* the new tests fail on upstream's current code and pass with step 1. +3. **All project checks** on Python 3.14, as CI runs them: `pytest`, `ruff check`, `ruff format --check`, `pylint`, `mypy`, and `codespell`. +4. **Upstream PR.** After your final approval, one commit goes on a clean branch cut from upstream `master`, holding only the fix and its tests (no plan or notes). You get a prefilled link to open the PR from your account. The PR text mentions that it touches the same lines as #902. + +## Contribution rules that apply +- `docs/contributing.rst` and `tests/README.md`: dev setup from `tests/requirements_test.txt`, pre-commit hooks, `pytest`, PRs from a fork. +- Pre-commit runs ruff (check and format, line length 109), codespell, pylint and mypy. CI (`validate.yml`, Python 3.14) runs hassfest, ruff, pytest with coverage, pylint and mypy. +- No PR template; we follow the maintainer's habits: one small fix per PR, with tests. Commits are signed off. + +## Who's on it +Engineer, Security Officer and Auditor. Skipped as too small for them: research (done while planning), QA (the Auditor runs the tests), and the plan check (its reviewer's monthly quota is used up). No second security review: nothing security-related is touched. + +## Risks +- **Conflict with #902:** both change `ast_classdef`. If #902 merges first, we update this branch (a few lines); if this merges first, #902 gets the same small update. +- **Behaviour change:** only code where a class body raises and the error is caught behaves differently, and it now behaves like Python. + +## Out of scope +- A class redefined with a body that raises losing its old value: #902's second commit already fixes that. +- Any other class-body behaviour. From 5aa2e0bb1c306278ce0409a87ebc606e1bc951d7 Mon Sep 17 00:00:00 2001 From: Sean Stoube <31805425+HoneyBearTech@users.noreply.github.com> Date: Fri, 20 Nov 2026 12:05:01 +0000 Subject: [PATCH 2/3] restore the scope when a class body raises ast_classdef switches into the class namespace before running the body and only switched back after the body finished normally. When the body raised, pyscript stayed in the class namespace, so after the exception was caught, later statements bound their names in the failed class instead of the script. Inside a function the scope stack was left one entry too long. Run the body in a try/finally so the outer scope is always restored, including for the SyntaxError raised for return or break in a class body. Add tests compared against CPython. Signed-off-by: Sean Stoube <31805425+HoneyBearTech@users.noreply.github.com> --- custom_components/pyscript/eval.py | 16 +++-- tests/test_unit_eval.py | 103 +++++++++++++++++++++++++++++ 2 files changed, 112 insertions(+), 7 deletions(-) diff --git a/custom_components/pyscript/eval.py b/custom_components/pyscript/eval.py index e27f430..2170028 100644 --- a/custom_components/pyscript/eval.py +++ b/custom_components/pyscript/eval.py @@ -1078,13 +1078,15 @@ async def ast_classdef(self, arg): sym_table = {} self.sym_table_stack.append(self.sym_table) self.sym_table = sym_table - for arg1 in arg.body: - val = await self.aeval(arg1) - if isinstance(val, EvalReturn): - raise SyntaxError(f"{val.name()} statement outside function") - if isinstance(val, EvalStopFlow): - raise SyntaxError(f"{val.name()} statement outside loop") - self.sym_table = self.sym_table_stack.pop() + try: + for arg1 in arg.body: + val = await self.aeval(arg1) + if isinstance(val, EvalReturn): + raise SyntaxError(f"{val.name()} statement outside function") + if isinstance(val, EvalStopFlow): + raise SyntaxError(f"{val.name()} statement outside loop") + finally: + self.sym_table = self.sym_table_stack.pop() decorators = [await self.aeval(dec) for dec in arg.decorator_list] sym_table["__init__evalfunc_wrap__"] = None diff --git a/tests/test_unit_eval.py b/tests/test_unit_eval.py index 549b725..ed0ebf9 100644 --- a/tests/test_unit_eval.py +++ b/tests/test_unit_eval.py @@ -2448,3 +2448,106 @@ async def test_with_exit_does_not_swallow_cancel(hass): await Function.waiter_sync() await Function.waiter_stop() await Function.reaper_stop() + + +CLASS_BODY_RAISES_SOURCE = """ +results = {} + +try: + class Foo: + a = 1 + raise ValueError("boom") +except ValueError: + pass +x = 5 +results["module"] = [x, "x" in globals()] + +def func(): + try: + class Bar: + b = 2 + raise ValueError("boom") + except ValueError: + pass + y = 7 + z = [y, "y" in locals()] + return z + +results["func"] = func() +results["func_global"] = "y" in globals() + +class Outer: + c = 3 + try: + class Inner: + d = 4 + raise ValueError("boom") + except ValueError: + pass + e = 5 + +results["nested"] = [Outer.c, Outer.e, hasattr(Outer, "d")] +""" + + +async def test_class_body_raises_matches_python(hass): + """Test that a class body that raises leaves the scope like Python, compared with CPython itself.""" + hass.data[DOMAIN] = {CONFIG_ENTRY: MockConfigEntry(domain=DOMAIN, data={CONF_ALLOW_ALL_IMPORTS: True})} + Function.init(hass) + State.init(hass) + State.register_functions() + TrigTime.init(hass) + + expected_ns = {} + exec(compile(CLASS_BODY_RAISES_SOURCE, "test", "exec"), expected_ns) # pylint: disable=exec-used + expected = expected_ns["results"] + + global_ctx = GlobalContext("test", global_sym_table={}, manager=GlobalContextMgr) + ast = AstEval("test", global_ctx=global_ctx) + Function.install_ast_funcs(ast) + ast.parse(CLASS_BODY_RAISES_SOURCE + "results\n") + assert await ast.eval() == expected + assert "x" in global_ctx.global_sym_table + assert not ast.sym_table_stack + + await Function.waiter_sync() + await Function.waiter_stop() + await Function.reaper_stop() + + +async def test_class_body_error_reaches_caller(hass): + """Test that an uncaught class body error reaches the caller and later runs are unaffected.""" + hass.data[DOMAIN] = {CONFIG_ENTRY: MockConfigEntry(domain=DOMAIN, data={CONF_ALLOW_ALL_IMPORTS: True})} + Function.init(hass) + State.init(hass) + State.register_functions() + TrigTime.init(hass) + + for source in [ + 'class Foo:\n raise ValueError("boom")\n', + "class Foo:\n return 1\n", + "class Foo:\n break\n", + ]: + with pytest.raises((ValueError, SyntaxError)): + exec(compile(source, "test", "exec"), {}) # pylint: disable=exec-used + + global_ctx = GlobalContext("test", global_sym_table={}, manager=GlobalContextMgr) + ast = AstEval("test", global_ctx=global_ctx) + Function.install_ast_funcs(ast) + for source, exc_type in [ + ('class Foo:\n raise ValueError("boom")\n', ValueError), + ("class Foo:\n for i in range(2):\n pass\n raise KeyError(1)\n", KeyError), + ]: + ast.parse(source) + with pytest.raises(exc_type): + await ast.eval() + assert ast.sym_table is ast.global_sym_table + assert not ast.sym_table_stack + + ast.parse("x = 5\nx\n") + assert await ast.eval() == 5 + assert global_ctx.global_sym_table["x"] == 5 + + await Function.waiter_sync() + await Function.waiter_stop() + await Function.reaper_stop() From 5cb6bb9034ba76efb0ed800e1fe01389cb7ca732 Mon Sep 17 00:00:00 2001 From: Sean Stoube <31805425+HoneyBearTech@users.noreply.github.com> Date: Fri, 20 Nov 2026 12:13:58 +0000 Subject: [PATCH 3/3] docs: record classdef-finally Signed-off-by: Sean Stoube <31805425+HoneyBearTech@users.noreply.github.com> --- docs/plans/classdef-finally.md | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/docs/plans/classdef-finally.md b/docs/plans/classdef-finally.md index efad7a0..2757857 100644 --- a/docs/plans/classdef-finally.md +++ b/docs/plans/classdef-finally.md @@ -35,3 +35,17 @@ Engineer, Security Officer and Auditor. Skipped as too small for them: research ## Out of scope - A class redefined with a body that raises losing its old value: #902's second commit already fixes that. - Any other class-body behaviour. + +--- + +## Record (2026-11-20) + +**Status:** built and checked, with no open problems. Not yet sent upstream. + +**What shipped on this branch:** one commit, `restore the scope when a class body raises` (`5aa2e0b`). It wraps the class-body loop in `ast_classdef` in `try`/`finally` (+9/−7) and adds two tests (+103) compared against CPython 3.14. It applies cleanly to upstream `master` (`8131a78`), and all 204 tests, ruff, pylint, mypy and codespell pass. + +**Checks:** the Security Officer reported it clear, and the Auditor approved with no findings. The audit also confirmed that the scope is restored for `return`/`break` in a class body and for task cancellation. Plan check, QA and plain-English check were skipped (job too small; the reviewer's quota was used up). + +**Decisions:** +- Cut from upstream `master`, not from #902's branch, so the fix can merge on its own. Whichever of the two merges second needs a small update. +- The class name left bound to an undefined placeholder after a failed body is left alone: #902's second commit handles redefinition, and a first definition already gives NameError, as Python does.