virtualmodelcontrol 1.2.0__tar.gz → 1.2.1__tar.gz

{virtualmodelcontrol-1.2.0 → virtualmodelcontrol-1.2.1}/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to this project are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and versions follow
 [Semantic Versioning](https://semver.org/) (0.x: the API may change between minor versions).
 
+## [1.2.1] - 2026-10-10
+
+A patch: a Ctrl-C can no longer lose the log of a real-time run. Nothing else changes.
+
+### Fixed
+
+- A Ctrl-C (or `_thread.interrupt_main()`) that arrived in the middle of a real-time step could land
+  inside a call into CasADi or numpy, come out as a `SystemError` and lose the log. On the main thread,
+  with Python's own handler on SIGINT, `sim.run` now only raises a flag, reads it between two steps and
+  returns the log; a second Ctrl-C raises at once, for a run that is stuck. A handler of your own, and
+  any other thread, are left alone.
+
 ## [1.2.0] - 2026-10-09
 
 A robot that runs for hours: the log of a real-time run can keep only its last seconds. Nothing that

{virtualmodelcontrol-1.2.0 → virtualmodelcontrol-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: virtualmodelcontrol
-Version: 1.2.0
+Version: 1.2.1
 Summary: Virtual Model Control: robots and controllers as mechanisms of springs, dampers and inertances, compiled with CasADi.
 Project-URL: Repository, https://github.com/vigno0405/VirtualModelControl
 Project-URL: Documentation, https://vigno0405.github.io/VirtualModelControl/

{virtualmodelcontrol-1.2.0 → virtualmodelcontrol-1.2.1}/docs/installation.md

@@ -120,10 +120,10 @@ pip install -e .
 An experiment should always run the same code. Pin the version, and move the pin on purpose:
 
 ```bash
-pip install "virtualmodelcontrol==1.2.0"
+pip install "virtualmodelcontrol==1.2.1"
 ```
 
-In a `requirements.txt` file, write `virtualmodelcontrol==1.2.0`. In a conda `environment.yml`,
+In a `requirements.txt` file, write `virtualmodelcontrol==1.2.1`. In a conda `environment.yml`,
 list it under `pip:`. `pip show virtualmodelcontrol` tells you which version you have, and the
 [changelog](development/changelog.md) what changed between versions.
 

{virtualmodelcontrol-1.2.0 → virtualmodelcontrol-1.2.1}/docs/tutorials/real-time.md

@@ -369,8 +369,10 @@ assert old.info["stale"] == len(old.arrays()["t"])
 assert not old.arrays()["motor_torque"].any() and blind.info["guard_trips"] > 20
 ```
 
-**Ctrl-C.** It ends a real-time run with the log so far. Here the controller raises it at its
-60th step:
+**Ctrl-C.** It ends a real-time run with the log so far. The step that is running finishes first
+(an interrupt in the middle of a step could land inside a call into CasADi or numpy and lose the log),
+and a second Ctrl-C stops the run at once, for one that is stuck. A signal handler of your own is
+left alone. Here the controller raises it at its 60th step:
 
 ```{code-cell} python
 class Stop(Slow):

{virtualmodelcontrol-1.2.0 → virtualmodelcontrol-1.2.1}/src/virtualmodelcontrol/_version.py

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

{virtualmodelcontrol-1.2.0 → virtualmodelcontrol-1.2.1}/src/virtualmodelcontrol/sim/run.py

@@ -2,9 +2,12 @@
 
 from __future__ import annotations
 
+import contextlib
+import signal
+import threading
 import time
 import warnings
-from collections.abc import Callable, Iterable
+from collections.abc import Callable, Iterable, Iterator
 from dataclasses import dataclass
 from datetime import datetime
 from typing import Any
@@ -69,7 +72,7 @@ def run(
     Each step reads the plant, asks the controller for a command (zero torque if the guard
     trips), writes it, then advances a simulated plant by ``clock.dt`` or, with a ``WallClock``,
     waits for the next step. On real time, ``T=None`` runs until Ctrl-C, and Ctrl-C ends the run
-    with the log so far. ``z0`` sets the controller's initial
+    with the log so far, after the step that is running. ``z0`` sets the controller's initial
     virtual state, or is a function of the first reading that returns it. The log holds, at every
     step, the measurements, the command (and the law's torque before any output stage), the
     virtual state ``z`` when the controller has one, and what ``record`` asks for (see
@@ -186,6 +189,36 @@ def _reset(controller: Any, t: float, meas: Signals, z0: Any) -> None:
         controller.reset(t, meas, z0=z0)
 
 
+@contextlib.contextmanager
+def _ctrl_c_waits_for_the_step() -> Iterator[Callable[[], bool]]:
+    """Ctrl-C waits for the step that is running.
+
+    On the main thread, with Python's own handler on SIGINT, a first Ctrl-C only raises a flag
+    that the loop reads between two steps. An interrupt raised in the middle of a step can land
+    inside a call into C code (CasADi, numpy), which turns it into a SystemError and loses the log.
+    A second Ctrl-C raises KeyboardInterrupt at once, for a run that is stuck. Any other handler,
+    and any other thread, is left alone.
+    """
+    flag = threading.Event()
+    ours = (
+        threading.current_thread() is threading.main_thread()
+        and signal.getsignal(signal.SIGINT) is signal.default_int_handler
+    )
+
+    def on_sigint(signum: int, frame: object) -> None:
+        if flag.is_set():
+            raise KeyboardInterrupt
+        flag.set()
+
+    if ours:
+        signal.signal(signal.SIGINT, on_sigint)
+    try:
+        yield flag.is_set
+    finally:
+        if ours:
+            signal.signal(signal.SIGINT, signal.default_int_handler)
+
+
 def _run_wall(
     plant: Any,
     controller: Any,
@@ -204,36 +237,37 @@ def _run_wall(
     _reset(controller, 0.0, meas, z0)
     _describe(log, plant, controller)
     steps = overruns = stale = dropped = 0
-    try:
-        while limit is None or steps < limit:
-            now = clock.now()
-            t = now - t0
-            meas = plant.read()
-            old = clock.stale is not None and plant.t - meas.t > clock.stale
-            stale += old
-            good = guard.ok(meas) and not old
-            if good:
-                cmd = controller.step(t, meas)
-            else:
-                cmd = Signals(t, motor_torque=np.zeros(motors))
-            plant.write(cmd)
-            values = _values(t, cmd, meas, controller, plant, extras if good else None)
-            log.step(dt=now - previous, **values)
-            steps += 1
-            if window is not None and len(log.rows["t"]) > 1.25 * window / clock.dt:
-                # a fifth at a time: trimming a list costs its length
-                drop = len(log.rows["t"]) // 5
-                dropped += drop
-                for rows in log.rows.values():
-                    del rows[:drop]
-            previous, tick = now, tick + clock.dt
-            wait = tick - clock.now()
-            if wait > 0:
-                clock.sleep(wait)
-            else:  # late: start again from now rather than catching up in a burst
-                overruns, tick = overruns + 1, clock.now()
-    except KeyboardInterrupt:  # Ctrl-C ends a real-time run with the log so far
-        log.rows = {name: rows[: steps - dropped] for name, rows in log.rows.items()}
+    with _ctrl_c_waits_for_the_step() as interrupted:
+        try:
+            while (limit is None or steps < limit) and not interrupted():
+                now = clock.now()
+                t = now - t0
+                meas = plant.read()
+                old = clock.stale is not None and plant.t - meas.t > clock.stale
+                stale += old
+                good = guard.ok(meas) and not old
+                if good:
+                    cmd = controller.step(t, meas)
+                else:
+                    cmd = Signals(t, motor_torque=np.zeros(motors))
+                plant.write(cmd)
+                values = _values(t, cmd, meas, controller, plant, extras if good else None)
+                log.step(dt=now - previous, **values)
+                steps += 1
+                if window is not None and len(log.rows["t"]) > 1.25 * window / clock.dt:
+                    # a fifth at a time: trimming a list costs its length
+                    drop = len(log.rows["t"]) // 5
+                    dropped += drop
+                    for rows in log.rows.values():
+                        del rows[:drop]
+                previous, tick = now, tick + clock.dt
+                wait = tick - clock.now()
+                if wait > 0:
+                    clock.sleep(wait)
+                else:  # late: start again from now rather than catching up in a burst
+                    overruns, tick = overruns + 1, clock.now()
+        except KeyboardInterrupt:  # Ctrl-C ends a real-time run with the log so far
+            log.rows = {name: rows[: steps - dropped] for name, rows in log.rows.items()}
     dt = np.diff(log.arrays()["t"].ravel()) if steps > 1 else np.array([clock.dt])
     log.info = {
         "steps": steps,

{virtualmodelcontrol-1.2.0 → virtualmodelcontrol-1.2.1}/tests/sim/test_wallclock.py

@@ -1,5 +1,7 @@
 """The run loop on real time: steps on schedule, measured time, stale readings, overruns."""
 
+import signal
+import threading
 import time
 
 import numpy as np
@@ -120,6 +122,80 @@ def test_ctrl_c_ends_a_real_time_run_with_the_log_so_far():
     assert len(rows["t"]) == len(rows["motor_torque"]) == len(rows["motor_position"]) == 5
 
 
+@pytest.fixture
+def pythons_sigint_handler():
+    """SIGINT as a plain Python program has it, and whatever it was put back afterwards."""
+    before = signal.signal(signal.SIGINT, signal.default_int_handler)
+    yield
+    signal.signal(signal.SIGINT, before)
+
+
+def test_a_ctrl_c_in_the_middle_of_a_step_ends_the_run_after_that_step(pythons_sigint_handler):
+    """The step is never interrupted: inside a call into C code (CasADi, numpy) the interrupt would
+    come out as a SystemError and the log would be lost."""
+
+    class Signalled(Controller):
+        def step(self, t, meas):
+            out = super().step(t, meas)
+            if len(self.times) == 5:
+                signal.raise_signal(signal.SIGINT)  # as it arrives in the middle of the step
+            return out
+
+    time = FakeTime()
+    clock = vmc.sim.WallClock(dt=0.01, now=time.now, sleep=time.sleep)
+    log = vmc.sim.run(Plant(time), Signalled(time), clock, T=None)
+    rows = log.arrays()
+    assert log.info["steps"] == 5 and all(
+        len(v) == 5 for v in rows.values()
+    )  # whole steps, the fifth too
+    assert (
+        signal.getsignal(signal.SIGINT) is signal.default_int_handler
+    )  # and the handler is put back
+
+
+def test_a_second_ctrl_c_stops_a_run_at_once(pythons_sigint_handler):
+    class Stuck(Controller):
+        def step(self, t, meas):
+            if len(self.times) == 2:
+                signal.raise_signal(signal.SIGINT)
+                signal.raise_signal(signal.SIGINT)  # the first only asked; this one raises
+            return super().step(t, meas)
+
+    time = FakeTime()
+    clock = vmc.sim.WallClock(dt=0.01, now=time.now, sleep=time.sleep)
+    log = vmc.sim.run(Plant(time), Stuck(time), clock, T=None)
+    assert log.info["steps"] == 2 and all(len(v) == 2 for v in log.arrays().values())
+    assert signal.getsignal(signal.SIGINT) is signal.default_int_handler
+
+
+def test_a_handler_of_the_program_and_other_threads_are_left_alone(pythons_sigint_handler):
+    seen = []
+    mine = lambda *_: seen.append(1)  # noqa: E731
+    signal.signal(signal.SIGINT, mine)
+
+    class Looking(Controller):
+        def step(self, t, meas):
+            seen.append(signal.getsignal(signal.SIGINT) is mine)
+            return super().step(t, meas)
+
+    time = FakeTime()
+    clock = vmc.sim.WallClock(dt=0.01, now=time.now, sleep=time.sleep)
+    vmc.sim.run(Plant(time), Looking(time), clock, T=0.03)
+    assert seen == [True] * 3 and signal.getsignal(signal.SIGINT) is mine
+    signal.signal(signal.SIGINT, signal.default_int_handler)
+    done = []
+
+    def in_a_thread():  # signals can only be set on the main thread: no error, the run just goes
+        time = FakeTime()
+        clock = vmc.sim.WallClock(dt=0.01, now=time.now, sleep=time.sleep)
+        done.append(vmc.sim.run(Plant(time), Controller(time), clock, T=0.03).info["steps"])
+
+    thread = threading.Thread(target=in_a_thread)
+    thread.start()
+    thread.join()
+    assert done == [3]
+
+
 def test_a_simulated_run_needs_its_duration():
     with pytest.raises(ValueError, match="duration"):
         vmc.sim.run(None, None, vmc.sim.SimClock(0.01), T=None)

virtualmodelcontrol-1.2.1/tests/test_python_versions.py

@@ -0,0 +1,58 @@
+"""Everything written in Python compiles on the oldest Python the library supports.
+
+A syntax of a newer Python is the usual surprise on a student's machine (an f-string that reuses
+its own quotes is legal on 3.12 and a SyntaxError on 3.10). The tests import only some modules and
+the docs build runs only some snippets, so this reads them all: every ``.py`` file of the
+repository and every Python code block of the Markdown pages. It fails on the 3.10 job of the CI,
+which is where it matters; a newer interpreter at least catches the warnings that are going to be
+errors.
+"""
+
+import re
+import warnings
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+SKIP = {
+    ".git",
+    ".venv",
+    "venv",
+    "_build",
+    "build",
+    "dist",
+    "node_modules",
+    ".claude",
+    "__pycache__",
+}
+FENCE = re.compile(r"^(`{3,})\s*(\{code-cell\}\s*python|python|py)\s*$(.*?)^\1\s*$", re.S | re.M)
+
+
+def sources():
+    for path in sorted(ROOT.rglob("*")):
+        if SKIP & set(path.relative_to(ROOT).parts):
+            continue
+        if path.suffix == ".py":
+            yield str(path.relative_to(ROOT)), path.read_text(encoding="utf-8")
+        elif path.suffix == ".md":
+            for i, block in enumerate(FENCE.finditer(path.read_text(encoding="utf-8"))):
+                body = block.group(3)
+                if block.group(2).startswith(
+                    "{"
+                ):  # a MyST cell: its options (:tags: ...) are not code
+                    body = "\n".join(line for line in body.splitlines() if not line.startswith(":"))
+                yield f"{path.relative_to(ROOT)} (block {i + 1})", body
+
+
+def test_every_python_file_and_docs_snippet_compiles_on_the_oldest_supported_python():
+    problems, count = [], 0
+    with warnings.catch_warnings():
+        warnings.simplefilter("error", SyntaxWarning)
+        warnings.simplefilter("error", DeprecationWarning)
+        for name, text in sources():
+            count += 1
+            try:
+                compile(text, name, "exec")
+            except (SyntaxError, SyntaxWarning, DeprecationWarning) as exc:
+                problems.append(f"{name}: {type(exc).__name__}: {exc}")
+    assert count > 400, "the repository was not found where this test expects it"
+    assert not problems, "\n".join(problems)