virtualmodelcontrol 1.1.0__tar.gz → 1.2.1__tar.gz

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

@@ -4,6 +4,31 @@ 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
+worked before changes.
+
+### Added
+
+- `sim.run(..., window=)`: on real time, a run that goes on for hours keeps only the last `window`
+  seconds of its log (up to a quarter more, until the next trim) instead of every step in memory;
+  `info["steps"]` still counts them all, and a Ctrl-C keeps only whole steps.
+- `RunLog.crop(t_min, t_max)`: the steps of a time window as a new log, with the same `info` and
+  `meta`; an end left out is open.
+
 ## [1.1.0] - 2026-10-09
 
 Static friction of the motors: a model of it, a compensation for it, its identification and a

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: virtualmodelcontrol
-Version: 1.1.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.1.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.1.0"
+pip install "virtualmodelcontrol==1.2.1"
 ```
 
-In a `requirements.txt` file, write `virtualmodelcontrol==1.1.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.1.0 → virtualmodelcontrol-1.2.1}/docs/troubleshooting.md

@@ -32,7 +32,7 @@ sudo apt install python3-venv
 pip installs CasADi from a prebuilt wheel. If pip starts building CasADi from source, or
 `import casadi` fails, there is no wheel for your Python version or platform. Create the
 environment with a Python version listed among the files on CasADi's
-[PyPI page](https://pypi.org/project/casadi/#files).
+[PyPI page](https://pypi.org/project/casadi/).
 
 ## Compiling takes long
 

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

@@ -132,6 +132,29 @@ length of each step. `log.info` counts the `overruns` (steps longer than the per
 `stale` readings the loop refused as too old and the `guard_trips` (readings missing or not
 numbers). A refused reading means zero torque for that step.
 
+A run that goes on for hours would keep every step in memory. With `window` [s], `run` keeps
+only the last seconds of the log (up to a quarter more, until it trims), and `log.info["steps"]`
+still counts every step. `log.crop(t_min, t_max)` takes a part of any log:
+
+```{code-cell} python
+driver = Driver()
+clock = vmc.sim.WallClock(1 / 330, 0.05, now=driver.time,
+                          sleep=driver.sim.advance)
+long = vmc.sim.run(Plant(driver), controller, clock, T=3.0, window=1.0)
+kept = long.arrays()["t"].ravel()
+last = long.crop(t_min=kept[-1] - 0.5)  # the last half second
+len(kept), len(last.arrays()["t"])
+```
+
+```{code-cell} python
+:tags: [remove-cell]
+assert long.info["steps"] == 990 and 330 <= len(kept) <= 413
+assert abs(kept[-1] - 989 / 330) < 1e-9 and 160 <= len(last.arrays()["t"]) <= 167
+glue("kept", len(kept), display=False)
+```
+
+The log holds {glue:text}`kept` of the 990 steps, the last second or so, and nothing older.
+
 `run` does not close the plant: do it yourself, with `try` and `finally`:
 
 ```python
@@ -346,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.1.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.1.0'
-__version_tuple__ = version_tuple = (1, 1, 0)
+__version__ = version = '1.2.1'
+__version_tuple__ = version_tuple = (1, 2, 1)
 
 __commit_id__ = commit_id = None

{virtualmodelcontrol-1.1.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
@@ -62,18 +65,21 @@ def run(
     guard: Guard | None = None,
     z0: Any = None,
     record: Iterable[str] | str = (),
+    window: float | None = None,
 ) -> RunLog:
     """Run ``controller`` on ``plant`` for ``T`` [s]; returns the recorded 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
     ``RECORDS``); a value the step did not compute is NaN. Its ``meta`` holds the Params at the
-    start and the plant's hardware profile.
+    start and the plant's hardware profile. On real time, ``window`` [s] keeps only the last
+    seconds of a run that goes on for hours (up to a quarter more, until the next trim);
+    ``info["steps"]`` still counts them all.
     """
     guard = Guard() if guard is None else guard
     extras = _extras(record)
@@ -83,8 +89,10 @@ def run(
         raise ValueError(
             "record='robot' needs a simulated plant: a real robot does not report forces"
         )
+    if window is not None and not isinstance(clock, WallClock):
+        raise ValueError("window is for a real-time run: a simulated one has its duration")
     if isinstance(clock, WallClock):
-        return _run_wall(plant, controller, clock, T, guard, z0, extras)
+        return _run_wall(plant, controller, clock, T, guard, z0, extras, window)
     if T is None:
         raise ValueError("a simulated run needs its duration T")
     log = RunLog()
@@ -181,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,
@@ -189,6 +227,7 @@ def _run_wall(
     guard: Guard,
     z0: Any,
     extras: Callable[[Any, Any], dict[str, Any]],
+    window: float | None,
 ) -> RunLog:
     """The run loop on real time: measured steps, stale readings refused, rate statistics."""
     log, limit = RunLog(), None if T is None else round(T / clock.dt)
@@ -197,31 +236,38 @@ def _run_wall(
     t0 = previous = tick = clock.now()
     _reset(controller, 0.0, meas, z0)
     _describe(log, plant, controller)
-    steps = overruns = stale = 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
-            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] for name, rows in log.rows.items()}
+    steps = overruns = stale = dropped = 0
+    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.1.0 → virtualmodelcontrol-1.2.1}/src/virtualmodelcontrol/sim/runlog.py

@@ -50,6 +50,17 @@ class RunLog:
         """Each signal as an (n_steps, ...) array."""
         return {name: np.array(rows) for name, rows in self.rows.items()}
 
+    def crop(self, t_min: float | None = None, t_max: float | None = None) -> RunLog:
+        """The steps with ``t_min`` ≤ t ≤ ``t_max`` [s] (an end left out is open), as a new log with
+        the same ``info`` and ``meta``."""
+        t = np.array([row[0] for row in self.rows["t"]])
+        keep = np.flatnonzero(
+            (t >= (-np.inf if t_min is None else t_min))
+            & (t <= (np.inf if t_max is None else t_max))
+        )
+        rows = {name: [values[i] for i in keep] for name, values in self.rows.items()}
+        return RunLog(rows, dict(self.info), dict(self.meta))
+
     def save(self, path: str | os.PathLike[str], *, overwrite: bool = False) -> Path:
         """Write the log as a compressed ``.npz`` and return its path. The file is written whole or
         not at all (through a temporary file), and an existing one is kept unless ``overwrite``."""

{virtualmodelcontrol-1.1.0 → virtualmodelcontrol-1.2.1}/tests/sim/test_runlog.py

@@ -167,3 +167,31 @@ def test_the_library_reads_runs_of_its_own_simulator(tmp_path):
     assert back.meta == log.meta and back.meta["library"] == vmc.__version__
     for name, values in log.arrays().items():
         np.testing.assert_array_equal(back.arrays()[name], values, err_msg=name)
+
+
+def test_crop_keeps_the_steps_of_a_time_window_and_leaves_the_log_as_it_was():
+    log = example_log()
+    part = log.crop(0.25, 1.0)
+    rows = part.arrays()
+    np.testing.assert_array_equal(rows["t"].ravel(), [0.5, 1.0])
+    np.testing.assert_array_equal(rows["q"], [[3.0, 4.0], [5.0, 6.0]])
+    assert rows["tag"].shape == (2, 1) and np.isnan(rows["tag"]).all()  # the names stay, aligned
+    assert part.info == log.info and part.meta == log.meta
+    part.info["steps"] = 0  # a copy: the original is not touched
+    assert log.info["steps"] == 3 and len(log.arrays()["t"]) == 3
+    np.testing.assert_array_equal(
+        log.crop(t_max=0.5).arrays()["t"].ravel(), [0.0, 0.5]
+    )  # open ends
+    np.testing.assert_array_equal(log.crop(t_min=0.6).arrays()["t"].ravel(), [1.0])
+    assert len(log.crop().arrays()["t"]) == 3 and len(log.crop(2.0, 3.0).rows["t"]) == 0
+    np.testing.assert_array_equal(
+        log.crop(0.5, 0.5).arrays()["t"].ravel(), [0.5]
+    )  # both ends count
+
+
+def test_crop_with_an_open_end_takes_every_time_on_that_side():
+    log = RunLog()
+    for t in (-1.0, 0.0, 5.0):
+        log.step(t=t, q=[t])
+    np.testing.assert_array_equal(log.crop(t_max=0.0).arrays()["t"].ravel(), [-1.0, 0.0])
+    np.testing.assert_array_equal(log.crop(t_min=0.0).arrays()["t"].ravel(), [0.0, 5.0])

virtualmodelcontrol-1.2.1/tests/sim/test_wallclock.py

@@ -0,0 +1,247 @@
+"""The run loop on real time: steps on schedule, measured time, stale readings, overruns."""
+
+import signal
+import threading
+import time
+
+import numpy as np
+import pytest
+
+import virtualmodelcontrol as vmc
+from virtualmodelcontrol.robots import adapt
+
+
+class FakeTime:
+    """A clock that moves only when the loop sleeps or a step takes time."""
+
+    def __init__(self):
+        self.t = 100.0
+
+    def now(self):
+        return self.t
+
+    def sleep(self, seconds):
+        self.t += seconds
+
+
+class Computer:
+    """The computer's own clock, as the time of a plant."""
+
+    @property
+    def t(self):
+        return time.monotonic()
+
+
+class Plant:
+    """Two motors at rest; ``lag`` [s] makes every reading that old."""
+
+    def __init__(self, time, lag=0.0):
+        self.time, self.lag, self.sent = time, lag, []
+
+    @property
+    def t(self):
+        return self.time.t
+
+    def read(self):
+        return vmc.Signals(
+            self.t - self.lag, motor_position=np.zeros(2), motor_velocity=np.zeros(2)
+        )
+
+    def write(self, cmd):
+        self.sent.append(np.array(cmd["motor_torque"]))
+
+
+class Controller:
+    """Constant torque; each step takes ``cost`` [s] of the fake clock."""
+
+    def __init__(self, time, cost=0.0):
+        self.time, self.cost, self.times = time, cost, []
+
+    def reset(self, t, meas):
+        pass
+
+    def step(self, t, meas):
+        self.times.append(t)
+        self.time.t += self.cost
+        return vmc.Signals(t, motor_torque=np.ones(2))
+
+
+def test_steps_run_on_schedule_with_the_measured_time():
+    time = FakeTime()
+    clock = vmc.sim.WallClock(dt=0.01, now=time.now, sleep=time.sleep)
+    controller = Controller(time, cost=0.002)
+    log = vmc.sim.run(Plant(time), controller, clock, T=0.1)
+    np.testing.assert_allclose(controller.times, np.arange(10) * 0.01, atol=1e-12)
+    assert log.info["steps"] == 10 and log.info["overruns"] == 0
+    assert log.info["rate"] == pytest.approx(100.0)
+    np.testing.assert_allclose(log.arrays()["dt"][1:].ravel(), 0.01)
+
+
+def test_late_steps_are_counted_and_warned_without_a_burst():
+    time = FakeTime()
+    clock = vmc.sim.WallClock(dt=0.01, now=time.now, sleep=time.sleep)
+    controller = Controller(time, cost=0.015)
+    with pytest.warns(RuntimeWarning, match="10 of 10 steps took longer than 10.0 ms"):
+        log = vmc.sim.run(Plant(time), controller, clock, T=0.1)
+    assert log.info["overruns"] == 10
+    np.testing.assert_allclose(np.diff(controller.times), 0.015)  # never squeezed to catch up
+
+
+def test_stale_readings_send_zero_torque():
+    time = FakeTime()
+    clock = vmc.sim.WallClock(dt=0.01, stale=0.05, now=time.now, sleep=time.sleep)
+    plant, controller = Plant(time, lag=0.2), Controller(time)
+    log = vmc.sim.run(plant, controller, clock, T=0.05)
+    assert log.info["stale"] == 5 and controller.times == []
+    assert all(np.all(u == 0.0) for u in plant.sent)
+
+
+def test_a_real_time_run_on_the_computers_clock_is_paced():
+    robot, ctrl = adapt.finger(), vmc.Mechanism("ctrl")
+    ctrl.add("hold", vmc.LinearSpring(robot.joint(slice(0, 2)), 1.0))
+    controller = vmc.VMCController(vmc.compile(vmc.VirtualMechanismSystem(robot, ctrl)))
+    clock = vmc.sim.WallClock(dt=0.005, stale=0.05)
+    log = vmc.sim.run(Plant(Computer()), controller, clock, T=0.1)
+    assert log.info["steps"] == 20 and log.info["stale"] == 0
+    assert 20.0 < log.info["rate"] < 300.0  # paced at 200 Hz, as far as a busy computer lets it
+
+
+def test_ctrl_c_ends_a_real_time_run_with_the_log_so_far():
+    time = FakeTime()
+
+    class Interrupted(Controller):
+        def step(self, t, meas):
+            if len(self.times) == 5:
+                raise KeyboardInterrupt
+            return super().step(t, meas)
+
+    clock = vmc.sim.WallClock(dt=0.01, now=time.now, sleep=time.sleep)
+    log = vmc.sim.run(Plant(time), Interrupted(time), clock, T=None)
+    rows = log.arrays()
+    assert log.info["steps"] == 5
+    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)
+
+
+def test_a_window_keeps_the_last_seconds_of_a_run_that_goes_on():
+    for steps in range(300, 313):  # the run ends at every point of the trimming cycle
+        time = FakeTime()
+        clock = vmc.sim.WallClock(dt=0.01, now=time.now, sleep=time.sleep)
+        log = vmc.sim.run(Plant(time), Controller(time), clock, T=steps * 0.01, window=0.5)
+        rows = log.arrays()
+        t = rows["t"].ravel()
+        assert log.info["steps"] == steps  # every step ran
+        assert 50 <= len(t) <= 62  # the last 0.5 s, and at most a quarter more
+        assert t[-1] == pytest.approx((steps - 1) * 0.01)  # the newest steps are the kept ones
+        np.testing.assert_allclose(np.diff(t), 0.01, atol=1e-9)  # no gap: the oldest rows went
+        assert all(len(v) == len(t) for v in rows.values())  # every signal was trimmed together
+    time = FakeTime()
+    clock = vmc.sim.WallClock(dt=0.01, now=time.now, sleep=time.sleep)
+    full = vmc.sim.run(Plant(time), Controller(time), clock, T=3.0)
+    assert len(full.arrays()["t"]) == 300  # without a window nothing is dropped
+
+
+def test_ctrl_c_in_the_middle_of_a_step_of_a_windowed_run_keeps_only_whole_steps(monkeypatch):
+    original = vmc.sim.runlog.RunLog.step
+    calls = []
+
+    def interrupted(self, **values):
+        calls.append(1)
+        if len(calls) == 121:  # the signal comes after the first signal of the step is logged
+            first, *_ = values
+            self.rows.setdefault(first, []).append(np.array([0.0]))
+            raise KeyboardInterrupt
+        original(self, **values)
+
+    monkeypatch.setattr(vmc.sim.runlog.RunLog, "step", interrupted)
+    time = FakeTime()
+    clock = vmc.sim.WallClock(dt=0.01, now=time.now, sleep=time.sleep)
+    log = vmc.sim.run(Plant(time), Controller(time), clock, T=None, window=0.5)
+    rows = log.arrays()
+    assert log.info["steps"] == 120 and 50 <= len(rows["t"]) <= 62
+    assert len({len(v) for v in rows.values()}) == 1 and rows["t"].ravel()[-1] == pytest.approx(
+        1.19
+    )
+
+
+def test_a_window_is_for_a_run_on_real_time():
+    with pytest.raises(ValueError, match="real-time"):
+        vmc.sim.run(None, None, vmc.sim.SimClock(0.01), T=1.0, window=0.5)

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)