labnotes 0.2.10__tar.gz → 0.2.12__tar.gz

{labnotes-0.2.10 → labnotes-0.2.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: labnotes
-Version: 0.2.10
+Version: 0.2.12
 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.2.10 → labnotes-0.2.12}/src/labnotes/runner/run_experiment.py

@@ -293,7 +293,7 @@ async def run_experiment(
         del running[run], trees[run]
         report({"event": "ended", "run": run, **result})
         ended[run] = params
-        results[run] = result
+        results[run] = {"run": run, **result}
         if result["exit_code"] == RETRY_EXIT_CODE and not (
             stopping.is_set() or run in stopped
         ):

labnotes-0.2.12/src/labnotes/tui/run_output.py

@@ -0,0 +1,106 @@
+import codecs
+from collections.abc import Iterable
+from pathlib import Path
+from typing import Self
+
+from rich.style import Style
+from rich.text import Text
+from rich.cells import cell_len
+from textual.geometry import Size
+from textual.strip import Strip
+from textual.widgets import Log
+
+from labnotes.latest_log import latest_log
+
+STREAMS = ("stdout", "stderr")
+
+
+class RunOutput(Log):
+    def __init__(self, id: str | None = None) -> None:
+        super().__init__(id=id)
+        self.reset()
+
+    def reset(self) -> None:
+        self.offsets = dict.fromkeys(STREAMS, 0)
+        self.paths: dict[str, Path] = {}
+        self.decoders = {
+            stream: codecs.getincrementaldecoder("utf-8")(errors="replace")
+            for stream in STREAMS
+        }
+        self.last_stream: str | None = None
+        self.unfinished = ""
+        self.clear()
+
+    @property
+    def mid_line(self) -> bool:
+        return bool(self.unfinished)
+
+    def follow(self, folder: Path) -> None:
+        for stream in STREAMS:
+            path = latest_log(folder, stream)
+            if not path.exists():
+                continue
+            if self.paths.setdefault(stream, path) != path:
+                self.paths[stream] = path
+                self.offsets[stream] = 0
+            with path.open("rb") as log:
+                log.seek(self.offsets[stream])
+                data = log.read()
+            self.offsets[stream] += len(data)
+            text = self.decoders[stream].decode(data)
+            if not text:
+                continue
+            # 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_unfinished()
+                text = self.unfinished + text
+            *complete, self.unfinished = text.split("\n")
+            if complete:
+                self.write_lines(complete)
+            if self.unfinished:
+                self.write_lines([self.unfinished])
+            self.last_stream = stream
+
+    def write_lines(self, lines: Iterable[str], scroll_end: bool | None = None) -> Self:
+        new_lines = list(lines)
+        if not new_lines:
+            return self
+        at_end = self.is_vertical_scroll_end
+        self._lines.extend(new_lines)
+        self._width = max(self._width, max(map(len, new_lines)))
+        self.virtual_size = Size(self._width, len(self._lines))
+        self.refresh()
+        if (
+            self.is_mounted
+            and (self.auto_scroll if scroll_end is None else scroll_end)
+            and at_end
+        ):
+            self.scroll_end(animate=False, immediate=True, x_axis=False)
+        return self
+
+    def drop_unfinished(self) -> None:
+        self._lines.pop()
+        self._render_line_cache.discard(len(self._lines))
+        self.virtual_size = Size(self._width, len(self._lines))
+        self.refresh()
+
+    def _render_line_strip(self, y: int, rich_style: Style) -> Strip:
+        selection = self.text_selection
+        if selection is None and y in self._render_line_cache:
+            return self._render_line_cache[y]
+        line_text = Text.from_ansi(self._lines[y], style=rich_style)
+        if selection is not None:
+            if (span := selection.get_span(y)) is not None:
+                start, end = span
+                if end == -1:
+                    end = len(line_text)
+                line_text.stylize(
+                    self.screen.get_component_rich_style("screen--selection"),
+                    start,
+                    end,
+                )
+        line = Strip(line_text.render(self.app.console), cell_len(line_text.plain))
+        if selection is None:
+            self._render_line_cache[y] = line
+        return line

{labnotes-0.2.10 → labnotes-0.2.12}/testing-conventions.toml

@@ -51,3 +51,9 @@ path = "src/labnotes/runner/hold_experiment.py"
 rules = ["mutation"]
 lines = [18]
 reason = "LOCK_EX and LOCK_NB are disjoint bits, so | equals + and ^"
+
+[[python.exempt]]
+path = "src/labnotes/tui/run_output.py"
+rules = ["mutation"]
+lines = [96]
+reason = "a selection span ends at -1 or a non-negative offset, so <= equals ==; -1 is a CPython cached small int, so is equals =="

labnotes-0.2.10/src/labnotes/tui/run_output.py

@@ -1,80 +0,0 @@
-import codecs
-from pathlib import Path
-from typing import Any, Self
-
-from rich.text import Text
-from textual.geometry import Size
-from textual.widgets import RichLog
-
-from labnotes.latest_log import latest_log
-
-STREAMS = ("stdout", "stderr")
-
-
-class RunOutput(RichLog):
-    def __init__(self, id: str | None = None) -> None:
-        super().__init__(id=id, wrap=True, min_width=1)
-        self.reset()
-
-    def reset(self) -> None:
-        self.offsets = dict.fromkeys(STREAMS, 0)
-        self.paths: dict[str, Path] = {}
-        self.decoders = {
-            stream: codecs.getincrementaldecoder("utf-8")(errors="replace")
-            for stream in STREAMS
-        }
-        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:
-        return bool(self.unfinished)
-
-    def follow(self, folder: Path) -> None:
-        for stream in STREAMS:
-            path = latest_log(folder, stream)
-            if not path.exists():
-                continue
-            if self.paths.setdefault(stream, path) != path:
-                self.paths[stream] = path
-                self.offsets[stream] = 0
-            with path.open("rb") as log:
-                log.seek(self.offsets[stream])
-                data = log.read()
-            self.offsets[stream] += len(data)
-            text = self.decoders[stream].decode(data)
-            if not text:
-                continue
-            # 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_unfinished()
-                text = self.unfinished + text
-            *complete, self.unfinished = text.split("\n")
-            if complete:
-                self.write(Text.from_ansi("\n".join(complete)))
-            if self.unfinished:
-                self.write(Text.from_ansi(self.unfinished))
-            self.last_stream = stream
-
-    # 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[-self.written_rows :]
-        self._line_cache.clear()
-        self.virtual_size = Size(self.virtual_size.width, len(self.lines))
-        self.refresh()