labnotes 0.0.104__tar.gz → 0.0.106__tar.gz

{labnotes-0.0.104 → labnotes-0.0.106}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: labnotes
-Version: 0.0.104
+Version: 0.0.106
 Summary: Browse experiment designs, notes, and run data from a folder.
 Project-URL: Repository, https://github.com/thekevinscott/labnotes
 Author-email: Kevin Scott <me@thekevinscott.com>

{labnotes-0.0.104 → labnotes-0.0.106}/src/labnotes/context.md

@@ -75,8 +75,11 @@ script so it writes its outputs there.
 Each param is appended as `--name value`, with the name as written (use
 `source-language` for a `--source-language` flag), booleans as 0 or 1, and lists
 and tables as JSON. labnotes writes `run.json` (params, created, ended, exit
-code), `stdout.log` and `stderr.log` to the
-run folder.
+code, `ended_by`, `signal`), `stdout.log` and `stderr.log` to the
+run folder. `ended_by` is `"timeout"`, `"stop"` (labnotes stopped it),
+`"signal"` (a signal labnotes didn't send, like the out-of-memory killer) or
+null (the script exited itself). `signal` is the signal number read from the
+exit code (negative, or 128 + N from the shell), else null.
 A run counts when it exited 0 and its `run.json` doesn't hold
 `"excluded": true`, so excluding a run by hand means adding that key; the next
 `run` replaces it. Other keys you add to `run.json` are kept and show in `run`.
@@ -133,7 +136,8 @@ going. Elsewhere, it prints a line per event instead.
 - `-e PATH` reads another file instead of `experiment.toml`.
 - `--timeout SECONDS` stops any one run still going after that many seconds:
   SIGTERM, then SIGKILL 5 seconds later. Its
-  `run.json` gets `"error": "timed out after ..."` next to its exit code.
+  `run.json` gets `"error": "timed out after ..."` and `"ended_by": "timeout"`
+  next to its exit code.
   Unset, runs have no time limit.
 - `run` hands its runs to the project's labnotes daemon, starting it if
   needed, and shows or waits for them. The daemon listens on a socket in

{labnotes-0.0.104 → labnotes-0.0.106}/src/labnotes/runner/execute_run.py

@@ -7,6 +7,7 @@ from pathlib import Path
 import psutil
 
 from labnotes.log_path import LOG_ENV
+from labnotes.runner.exit_signal import exit_signal
 from labnotes.runner.shell_command import shell_command
 from labnotes.runner.stop_then_kill import GRACE_SECONDS
 from labnotes.runner.wait_for_tree import wait_for_tree
@@ -26,6 +27,7 @@ async def execute_run(
     retry_of: str | None = None,
     timeout: float | None = None,
     stop: Callable[[], None] = lambda: None,
+    stopped: Callable[[], bool] = lambda: False,
 ) -> dict[str, object]:
     run: dict[str, object] = {
         "params": params,
@@ -33,6 +35,8 @@ async def execute_run(
         "ended": None,
         "exit_code": None,
         "error": None,
+        "ended_by": None,
+        "signal": None,
     }
     if retry_of is not None:
         run["retry_of"] = retry_of
@@ -70,7 +74,14 @@ async def execute_run(
                     kill_later = asyncio.get_running_loop().call_later(
                         GRACE_SECONDS, stop
                     )
-                run["exit_code"] = await exited
+                run["exit_code"] = code = await exited
+                run["signal"] = exit_signal(code)
+                if kill_later is not None:
+                    run["ended_by"] = "timeout"
+                elif stopping.is_set() or stopped():
+                    run["ended_by"] = "stop"
+                elif run["signal"] is not None:
+                    run["ended_by"] = "signal"
                 # The shell can exit on SIGTERM before what it started. Once
                 # stopping, the run stays killable until everything signalled
                 # is gone. A normal exit ends the run even if helpers linger.

labnotes-0.0.106/src/labnotes/runner/exit_signal.py

@@ -0,0 +1,11 @@
+import signal
+
+
+def exit_signal(exit_code: int | None) -> int | None:
+    if exit_code is None:
+        return None
+    if exit_code < 0:
+        return -exit_code
+    # A shell reports a child killed by signal N as exit 128 + N.
+    number = exit_code - 128
+    return number if 0 < number < signal.NSIG else None

{labnotes-0.0.104 → labnotes-0.0.106}/src/labnotes/runner/run_experiment.py

@@ -255,6 +255,7 @@ async def run_experiment(
             parents.get(run),
             timeout=timeout,
             stop=lambda: kill(run),
+            stopped=lambda: run in stopped,
         )
         del running[run], trees[run]
         report({"event": "ended", "run": run, **result})

{labnotes-0.0.104 → labnotes-0.0.106}/src/labnotes/tui/run_output.py

@@ -1,5 +1,6 @@
 import codecs
 from pathlib import Path
+from typing import Any, Self
 
 from rich.text import Text
 from textual.geometry import Size
@@ -10,7 +11,7 @@ STREAMS = ("stdout", "stderr")
 
 class RunOutput(RichLog):
     def __init__(self, id: str | None = None) -> None:
-        super().__init__(id=id)
+        super().__init__(id=id, wrap=True, min_width=1)
         self.reset()
 
     def reset(self) -> None:
@@ -21,7 +22,11 @@ class RunOutput(RichLog):
         }
         self.last_stream: str | None = None
         self.unfinished = ""
+        self.written_rows = 0
         self.clear()
+        # A hidden log has no width; writing now would wrap every line to one
+        # cell. Hold writes until it's shown and resized.
+        self._size_known = bool(self.scrollable_content_region.width)
 
     @property
     def mid_line(self) -> bool:
@@ -42,7 +47,7 @@ class RunOutput(RichLog):
             # A stream's unfinished line is redrawn as it grows, but the
             # other stream's output starts below it.
             if self.mid_line and stream == self.last_stream:
-                self.drop_last_line()
+                self.drop_unfinished()
                 text = self.unfinished + text
             *complete, self.unfinished = text.split("\n")
             if complete:
@@ -51,11 +56,19 @@ class RunOutput(RichLog):
                 self.write(Text.from_ansi(self.unfinished))
             self.last_stream = stream
 
-    def drop_last_line(self) -> None:
+    # Counted here, not in follow: writes made before the size is known
+    # render later, from on_resize.
+    def write(self, content: object, *args: Any, **kwargs: Any) -> Self:
+        rows = len(self.lines)
+        super().write(content, *args, **kwargs)
+        self.written_rows = len(self.lines) - rows
+        return self
+
+    def drop_unfinished(self) -> None:
         if not self._size_known:
             self._deferred_renders.pop()
             return
-        del self.lines[-1]
+        del self.lines[-self.written_rows :]
         self._line_cache.clear()
         self.virtual_size = Size(self.virtual_size.width, len(self.lines))
         self.refresh()

{labnotes-0.0.104 → labnotes-0.0.106}/testing-conventions.toml

@@ -69,3 +69,9 @@ path = "src/labnotes/runner/run_experiment.py"
 rules = ["mutation"]
 lines = [184, 263]
 reason = "a retry is only scheduled below the budget and each one adds one, so tried never passes retries: >= equals ==; both sides are small ints, which CPython caches, so is equals =="
+
+[[python.exempt]]
+path = "src/labnotes/runner/exit_signal.py"
+rules = ["mutation"]
+lines = [10]
+reason = "exit_code is non-negative here; when bit 7 is set, - 128 equals ^ 128, and when it is clear ^ 128 lands above NSIG like a non-positive difference"