cubievis 0.0.1__tar.gz

cubievis-0.0.1/.gitignore

@@ -0,0 +1,7 @@
+.venv/
+__pycache__/
+*.egg-info/
+.pytest_cache/
+.omc/
+generated/
+Fabbri_Linder*/

cubievis-0.0.1/CHANGELOG.md

@@ -0,0 +1,59 @@
+# Changelog
+
+## [0.0.1](https://github.com/cubiepy/cubievis/compare/v0.1.0...v0.0.1) (2026-10-06)
+
+
+### Features
+
+* any dimension on any axis, colour and frame roles, animation and collapsed frames, dataset kinds ([9f4739f](https://github.com/cubiepy/cubievis/commit/9f4739f54b6019be589f1e93d3ea3314fe8051a1))
+* axis limits are two-handled sliders across each axis's NaN-free data range ([01e020f](https://github.com/cubiepy/cubievis/commit/01e020f443d0e4e8e8519c6542ba98b2eb27bd60))
+* axis limits are two-handled sliders across each axis's NaN-free data range ([97403e6](https://github.com/cubiepy/cubievis/commit/97403e6e702bc49a7c333453c205eedfc3a15fb9))
+* batches are saved as a min/max pyramid store and viewed in a fastplotlib pane ([14464b3](https://github.com/cubiepy/cubievis/commit/14464b3b3a3f7361f82bca7aedf594b07d3d73c5))
+* CubieVis GUI with a fastplotlib batch viewer over a min/max pyramid store ([ce940c3](https://github.com/cubiepy/cubievis/commit/ce940c3fb75a577c5419a28d75170fca7a09606d))
+* CubieVis Qt GUI drives cubie from system definition to viewer ([b6e534e](https://github.com/cubiepy/cubievis/commit/b6e534e0d41e0ed09819bca831d5c1dadaaf4e4b))
+* local trace viewer with a self-describing dataset format ([07255fe](https://github.com/cubiepy/cubievis/commit/07255fe9593a2b2fc0fb7a8b8d0ab1be2d36707f))
+* point picking in the viewer feeds y0 ([#7](https://github.com/cubiepy/cubievis/issues/7)) ([ba74295](https://github.com/cubiepy/cubievis/commit/ba74295f44c76dd95b298c106fcafb331df1a2b9))
+* right-hand panel of X, Y, Z and Sweep axes with log/lin, limits and collapse/animate; sliders for unassigned parameters ([684e027](https://github.com/cubiepy/cubievis/commit/684e027ec7a38b6467c20b9971d98b36ad920fed))
+* run log lists each swept input's value count before solving ([eeacfca](https://github.com/cubiepy/cubievis/commit/eeacfcae6d2f69e9a37469bfd2bacff2aa21c154))
+* the viewer plots first and second time derivatives, defaults log-spaced inputs to log axes, opens older dataset.json batches, and starts 3D at an oblique view ([6894ed1](https://github.com/cubiepy/cubievis/commit/6894ed11b1abe0c4166168d93d10f0d1fbb4777f))
+* Y carries axis/collapse/animate modes; Sweep collapses or animates ([bb201c5](https://github.com/cubiepy/cubievis/commit/bb201c5169ec48de6a6904e5a5d671252f4aa6f4))
+
+
+### Bug Fixes
+
+* an overwrite holds the batch path in the viewer cache until the write finishes ([0f7a455](https://github.com/cubiepy/cubievis/commit/0f7a455ddaa91004e3f5d1626a0b3683d1506b08))
+* arrays save in slabs, overwriting a batch releases the viewer's memory maps, inputs are checked against the system precision, GUI flows are driven by pytest-qt ([881d37e](https://github.com/cubiepy/cubievis/commit/881d37e2bd611cfb1a3c7653b24336c0328e5924))
+* closing the main window closes the viewer pane, so its render canvas stops drawing ([#11](https://github.com/cubiepy/cubievis/issues/11)) ([9b13fed](https://github.com/cubiepy/cubievis/commit/9b13fed3d9024de710c6e80fa5451607192c0ab5))
+* curve coordinates pass to Plotly as typed arrays ([43361eb](https://github.com/cubiepy/cubievis/commit/43361eb0bf6adcf720d3a2b9428417667ca14e9a))
+* favicon requests answer 204 ([13ae904](https://github.com/cubiepy/cubievis/commit/13ae904ee04a1afd8e4d7e7745a70c5e08a972ea))
+* level pairs are stored in time order and span their blocks, and windows too short for a level draw raw samples ([#8](https://github.com/cubiepy/cubievis/issues/8)) ([5da5c52](https://github.com/cubiepy/cubievis/commit/5da5c526adc47e5f5232aac6db62257d2ce29653))
+* returning the viewer to 3D restores orbit controls ([f06f134](https://github.com/cubiepy/cubievis/commit/f06f13489f87361dd1388c58da8e9b2b03b4f87f))
+* store builds append each run chunk to its files in run order instead of writing through writable memmaps ([#9](https://github.com/cubiepy/cubievis/issues/9)) ([04a23a3](https://github.com/cubiepy/cubievis/commit/04a23a37ffe04a89b8f1aba1fafce95d8a9e05ac))
+* the GUI is driveable end to end after the first hands-on review ([2c3e98e](https://github.com/cubiepy/cubievis/commit/2c3e98e9423f57cbd62c86d9d89fd5286b5bf789))
+* the viewer keeps one canvas and switches its camera and controller, so returning to 3D restores orbiting ([83cb243](https://github.com/cubiepy/cubievis/commit/83cb243e00c6ff43e6417fefa6f4a51806e5b46c))
+* the viewer stays responsive on large sweeps ([4ba5a4c](https://github.com/cubiepy/cubievis/commit/4ba5a4cc598284f341fc49ff97ec6d83a8ba8c70))
+* trace requests read only what they return ([29781ca](https://github.com/cubiepy/cubievis/commit/29781cacced03c62722aab10332eea606a0bc2ce))
+* trace requests return full-resolution windows ([bf6adf5](https://github.com/cubiepy/cubievis/commit/bf6adf56d8498f1b71de9cda2aa6ef395bf369f6))
+* traces are POST-only and index files have one layout ([e43f131](https://github.com/cubiepy/cubievis/commit/e43f1315bf2d190afe193173fdfea637d1759463))
+* typed defaults and category moves apply after the build, constants are editable per batch, cubie batches open with the swept input on Y and the first variable on Z ([9a039c5](https://github.com/cubiepy/cubievis/commit/9a039c51ab2394264d3a30f4665c07efd4215359))
+* value cells take one-number expressions and name sweeps typed into them ([3ea6433](https://github.com/cubiepy/cubievis/commit/3ea6433a41b2660e7c0d353b95ec48c0e16af692))
+* viewer page has no header, settings dialog groups advanced rows, run pane takes a directory and batch name, outputs split into saves and summaries ([4e4df52](https://github.com/cubiepy/cubievis/commit/4e4df52307c4753aaed560403e1e6807f9ca838b))
+* viewer pane selects the opened dataset, category tables stretch their columns, number fields are line edits ([0d167e8](https://github.com/cubiepy/cubievis/commit/0d167e81f6d603bd663c4145099c2685bc20022b))
+* viewer server never binds a port in use ([7c5e974](https://github.com/cubiepy/cubievis/commit/7c5e9743ae6288623634e99f73510b445d272710))
+* wide views read the finest pyramid level, ticks follow every re-plan, and surfaces redraw in place ([a082178](https://github.com/cubiepy/cubievis/commit/a082178cb67dac49093f7433119cce74c264e903))
+
+
+### Documentation
+
+* docstrings and guides state behaviour in one line each ([a141b90](https://github.com/cubiepy/cubievis/commit/a141b900f1da4a2e7e46842a4c75ee0b181d3a33))
+* load_function docstring fits the line limit ([265042c](https://github.com/cubiepy/cubievis/commit/265042ce2816c97be0f2fecb0d15aee9d4383153))
+* README and app header tightened ([43eae6e](https://github.com/cubiepy/cubievis/commit/43eae6ec49c812b82075dbdf5efeccd33547343a))
+* test tiers for CPU and GPU-with-display runs; pytest-qt in the test extra ([eb9c11e](https://github.com/cubiepy/cubievis/commit/eb9c11e18db243db1ecec2532cbd551adc900b1e))
+* worktree venv layering is described ([b93e92f](https://github.com/cubiepy/cubievis/commit/b93e92fa63d9ce0c93e9aa7d54e4f0753090d0be))
+* worktree_setup docstring is one line ([567bd41](https://github.com/cubiepy/cubievis/commit/567bd4153a5cafc8869874e425ff1449314e5274))
+* write_store docstring is one line ([c654edc](https://github.com/cubiepy/cubievis/commit/c654edc863f85c55bd932ff5f26fe78440917d2e))
+
+
+### Miscellaneous Chores
+
+* first release is 0.0.1 ([0f230d6](https://github.com/cubiepy/cubievis/commit/0f230d65076e696da1967ac38df710b9951f8359))

cubievis-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Chris Cameron
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cubievis-0.0.1/PKG-INFO

@@ -0,0 +1,74 @@
+Metadata-Version: 2.5
+Name: cubievis
+Version: 0.0.1
+Summary: Data visualisation and integrator GUI for Cubie
+Project-URL: Homepage, https://github.com/cubiepy/cubievis
+Project-URL: Issues, https://github.com/cubiepy/cubievis/issues
+Author: Chris Cameron
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: attrs
+Requires-Dist: cubie>=0.15.1
+Requires-Dist: fastplotlib>=0.7
+Requires-Dist: numba
+Requires-Dist: numpy>=2.0
+Requires-Dist: pyqt6
+Requires-Dist: qtpy
+Provides-Extra: test
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: pytest-qt; extra == 'test'
+Description-Content-Type: text/markdown
+
+# CubieVis
+
+Qt GUI for [cubie](https://github.com/ccam80/cubie): define a system, pick an integrator, enter a batch, solve, view the traces.
+
+## Install and run
+
+```
+uv venv; uv pip install -e .[test]
+.venv/Scripts/python -m cubievis
+```
+
+`cubie[cuda12]`/`cubie[cuda13]` adds a CUDA toolkit when the machine has none.
+
+Worktrees share the main checkout's `.venv`: `python tools/worktree_setup.py` (run by orca through `orca.yaml`) layers a `.venv` that imports the worktree's `src`.
+
+## Using it
+
+1. **Add system…**: equations (`dx = ...`), a Python `f(t, y, p)`, or a `.txt`/`.py`/`.cellml` file; **Parse** fills the category tables (CellML shows its parsed equations); **Edit system…** reopens the current one; **Make constant**/**Make parameter** move selected rows, here and on the main window's tables.
+2. Enter **y0** and **parameters** as numbers, lists or numpy expressions; pick grid type, variables to save/summarise (**All**/**None**), their cadences, and summary metrics (`peaks` takes `n` in its second column).
+3. Pick an **integrator** (type to search) by **Go**; step sizes and tolerances sit beside it, **All settings…** holds the rest; a row passes only when its checkbox is set.
+4. Set timing, directory and results folder; the label by **Go** estimates runs and disk size; the log shows phase, elapsed time, then the result path. **Set y0 from run** copies a run's final state into y0.
+5. The viewer opens the batch; summaries are a second dataset in it. X, Y, Z and Sweep each take time, a swept input, or a variable or its first or second time derivative, with log/lin (log by default for log-spaced inputs) and limits. Y (holding time or an input) cycles axis/collapse/animate; Sweep cycles collapse/animate. **Lines/Surface** switches the drawing; inputs on no axis get sliders; zooming time in 2D reloads that span at finer resolution; hovering names the run. Older `dataset.json` batches are converted to a store when opened.
+6. **File → Save/Load session…** keeps systems, inputs and settings in a JSON file.
+
+## Layout
+
+| Module | Role |
+|---|---|
+| `schema.py` | Solver settings read from cubie's attrs classes: names, kinds, choices, defaults, applicability per algorithm and controller. |
+| `systems.py` | Build a `SymbolicODE` from a `SystemSpec` (equations, Python source, CellML); category tables. |
+| `inputs.py` | Values text and data files to arrays; `DriverSamples`; final states from a saved batch. |
+| `estimate.py` | Run count and on-disk size estimates shown beside Go. |
+| `session_store.py` | Session save/load as JSON. |
+| `jobs.py` | The one worker thread for cubie calls; phase and elapsed time from `default_timelogger.events`. |
+| `run.py` | Go: `build_grid`, `solve`, write the store. |
+| `store.py` | Batch store: raw (run, time) traces per variable plus min/max pyramids of the values and their first two time derivatives; windowed line queries; `dataset.json` import. |
+| `view_model.py` | Axis choices to lines, frames, colours, world coordinates and ticks. |
+| `session.py` | Built systems, the current solver, the worker. |
+| `widgets/` | One Qt module per pane; no cubie calls outside the worker. The viewer pane draws with fastplotlib. |
+
+## Tests
+
+```
+NUMBA_ENABLE_CUDASIM=1 .venv/Scripts/python -m pytest --ignore=tests/gui/test_main_window.py --ignore=tests/gui/test_viewer_pane.py
+.venv/Scripts/python -m pytest tests/gui/test_main_window.py tests/gui/test_viewer_pane.py tests/test_run.py   # GPU, needs a display
+.venv/Scripts/python bench/speed_check.py store|render <batch>     # store build and raw render timings
+.venv/Scripts/python bench/viewer_check.py <batch> <store>         # each viewer mode
+```
+
+## AI slop warning
+
+Any AI input into Cubie is reviewed line-by-line, so it is largely slop-free and the poor design choices are all human-made. This GUI did not get the same degree of human care - if it steers cubie, is usable, and looks ok, then it is clean enough. The code is therefore an AI wasteland - it will get cleaned up when it starts to fight development, not before, so read it at your peril.

cubievis-0.0.1/README.md

@@ -0,0 +1,52 @@
+# CubieVis
+
+Qt GUI for [cubie](https://github.com/ccam80/cubie): define a system, pick an integrator, enter a batch, solve, view the traces.
+
+## Install and run
+
+```
+uv venv; uv pip install -e .[test]
+.venv/Scripts/python -m cubievis
+```
+
+`cubie[cuda12]`/`cubie[cuda13]` adds a CUDA toolkit when the machine has none.
+
+Worktrees share the main checkout's `.venv`: `python tools/worktree_setup.py` (run by orca through `orca.yaml`) layers a `.venv` that imports the worktree's `src`.
+
+## Using it
+
+1. **Add system…**: equations (`dx = ...`), a Python `f(t, y, p)`, or a `.txt`/`.py`/`.cellml` file; **Parse** fills the category tables (CellML shows its parsed equations); **Edit system…** reopens the current one; **Make constant**/**Make parameter** move selected rows, here and on the main window's tables.
+2. Enter **y0** and **parameters** as numbers, lists or numpy expressions; pick grid type, variables to save/summarise (**All**/**None**), their cadences, and summary metrics (`peaks` takes `n` in its second column).
+3. Pick an **integrator** (type to search) by **Go**; step sizes and tolerances sit beside it, **All settings…** holds the rest; a row passes only when its checkbox is set.
+4. Set timing, directory and results folder; the label by **Go** estimates runs and disk size; the log shows phase, elapsed time, then the result path. **Set y0 from run** copies a run's final state into y0.
+5. The viewer opens the batch; summaries are a second dataset in it. X, Y, Z and Sweep each take time, a swept input, or a variable or its first or second time derivative, with log/lin (log by default for log-spaced inputs) and limits. Y (holding time or an input) cycles axis/collapse/animate; Sweep cycles collapse/animate. **Lines/Surface** switches the drawing; inputs on no axis get sliders; zooming time in 2D reloads that span at finer resolution; hovering names the run. Older `dataset.json` batches are converted to a store when opened.
+6. **File → Save/Load session…** keeps systems, inputs and settings in a JSON file.
+
+## Layout
+
+| Module | Role |
+|---|---|
+| `schema.py` | Solver settings read from cubie's attrs classes: names, kinds, choices, defaults, applicability per algorithm and controller. |
+| `systems.py` | Build a `SymbolicODE` from a `SystemSpec` (equations, Python source, CellML); category tables. |
+| `inputs.py` | Values text and data files to arrays; `DriverSamples`; final states from a saved batch. |
+| `estimate.py` | Run count and on-disk size estimates shown beside Go. |
+| `session_store.py` | Session save/load as JSON. |
+| `jobs.py` | The one worker thread for cubie calls; phase and elapsed time from `default_timelogger.events`. |
+| `run.py` | Go: `build_grid`, `solve`, write the store. |
+| `store.py` | Batch store: raw (run, time) traces per variable plus min/max pyramids of the values and their first two time derivatives; windowed line queries; `dataset.json` import. |
+| `view_model.py` | Axis choices to lines, frames, colours, world coordinates and ticks. |
+| `session.py` | Built systems, the current solver, the worker. |
+| `widgets/` | One Qt module per pane; no cubie calls outside the worker. The viewer pane draws with fastplotlib. |
+
+## Tests
+
+```
+NUMBA_ENABLE_CUDASIM=1 .venv/Scripts/python -m pytest --ignore=tests/gui/test_main_window.py --ignore=tests/gui/test_viewer_pane.py
+.venv/Scripts/python -m pytest tests/gui/test_main_window.py tests/gui/test_viewer_pane.py tests/test_run.py   # GPU, needs a display
+.venv/Scripts/python bench/speed_check.py store|render <batch>     # store build and raw render timings
+.venv/Scripts/python bench/viewer_check.py <batch> <store>         # each viewer mode
+```
+
+## AI slop warning
+
+Any AI input into Cubie is reviewed line-by-line, so it is largely slop-free and the poor design choices are all human-made. This GUI did not get the same degree of human care - if it steers cubie, is usable, and looks ok, then it is clean enough. The code is therefore an AI wasteland - it will get cleaned up when it starts to fight development, not before, so read it at your peril.

cubievis-0.0.1/pyproject.toml

@@ -0,0 +1,43 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "cubievis"
+version = "0.0.1"
+description = "Data visualisation and integrator GUI for Cubie"
+authors = [
+    { name="Chris Cameron" }
+]
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.11"
+dependencies = [
+    "numpy>=2.0",
+    "numba",
+    "attrs",
+    "cubie>=0.15.1",
+    "qtpy",
+    "PyQt6",
+    "fastplotlib>=0.7",
+]
+
+[project.urls]
+Homepage = "https://github.com/cubiepy/cubievis"
+Issues = "https://github.com/cubiepy/cubievis/issues"
+
+[project.optional-dependencies]
+test = ["pytest", "pytest-qt"]
+
+[project.scripts]
+cubievis = "cubievis.app:main"
+
+[tool.hatch.build.targets.sdist]
+exclude = [".claude", ".github", "bench", "tools", "orca.yaml", "AGENTS.md", "release-please-config.json", ".release-please-manifest.json"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/cubievis"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

cubievis-0.0.1/src/cubievis/__init__.py

@@ -0,0 +1 @@
+"""CubieVis: a data visualisation and integrator GUI for Cubie."""

cubievis-0.0.1/src/cubievis/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from cubievis.app import main
+
+sys.exit(main())

cubievis-0.0.1/src/cubievis/app.py

@@ -0,0 +1,15 @@
+"""Entry point: show the main window."""
+
+import sys
+
+
+def main() -> int:
+    from qtpy.QtWidgets import QApplication
+
+    from cubievis.session import Session
+    from cubievis.widgets.main_window import MainWindow
+
+    app = QApplication(sys.argv)
+    window = MainWindow(Session())
+    window.show()
+    return app.exec()

cubievis-0.0.1/src/cubievis/estimate.py

@@ -0,0 +1,50 @@
+"""Pre-run estimates: how many runs a batch makes and its size on disk."""
+
+import numpy as np
+
+from cubievis.schema import TIME_DOMAIN_OUTPUTS, metric_output_size
+
+
+def run_count(inputs: dict, grid_type: str) -> int:
+    """Runs the grid makes from ``{name: values}`` batch inputs."""
+    sizes = [np.asarray(values).size for values in inputs.values()]
+    if not sizes:
+        return 1
+    if grid_type == "verbatim":
+        return max(sizes)
+    count = 1
+    for size in sizes:
+        if size > 1:
+            count *= size
+    return count
+
+
+def batch_bytes(*, n_runs: int, duration: float, itemsize: int,
+                output_types: list, n_saved: int, n_summarised: int,
+                save_every: float = None, summarise_every: float = None,
+                dt: float = 0.01) -> int:
+    """Approximate bytes on disk; metric output types may carry ``[n]``."""
+    total = 0
+    save_every = save_every or dt or 0.01
+    traces = any(t in ("state", "observables") for t in output_types)
+    if traces and n_saved and duration > 0:
+        n_time = int(duration / save_every) + 1
+        total += n_time * n_saved * n_runs * itemsize
+        total += n_time * 8  # the shared time column
+    metrics = [t for t in output_types
+               if t.partition("[")[0] not in TIME_DOMAIN_OUTPUTS]
+    if metrics and n_summarised and duration > 0:
+        height = sum(metric_output_size(m) for m in metrics) * n_summarised
+        windows = int(duration / summarise_every) if summarise_every else 1
+        total += max(windows, 1) * height * n_runs * itemsize
+    return total
+
+
+def human_size(n_bytes: int) -> str:
+    """``n_bytes`` as a short human-readable size."""
+    size = float(n_bytes)
+    for unit in ("B", "kB", "MB", "GB"):
+        if size < 1000:
+            return f"{size:.0f} {unit}" if unit == "B" else f"{size:.1f} {unit}"
+        size /= 1000
+    return f"{size:.1f} TB"

cubievis-0.0.1/src/cubievis/inputs.py

@@ -0,0 +1,118 @@
+"""Turn typed values and data files into solver inputs."""
+
+import math
+from pathlib import Path
+
+import numpy as np
+
+from cubie import DriverSamples
+
+from cubievis.store import Store
+
+NAMESPACE = {
+    "np": np, "numpy": np, "pi": math.pi, "e": math.e,
+    "linspace": np.linspace, "logspace": np.logspace,
+    "geomspace": np.geomspace, "arange": np.arange, "array": np.array,
+    "zeros": np.zeros, "ones": np.ones, "full": np.full, "range": range,
+    "sin": np.sin, "cos": np.cos, "exp": np.exp, "log": np.log,
+    "sqrt": np.sqrt, "abs": np.abs,
+}
+
+
+def parse_values(text: str) -> np.ndarray:
+    """A 1-D float array from a number, a list or a numpy expression."""
+    text = text.strip()
+    if not text:
+        raise ValueError("No values given")
+    try:
+        value = eval(text, {"__builtins__": {}}, NAMESPACE)
+    except SyntaxError:
+        value = eval(f"[{text}]", {"__builtins__": {}}, NAMESPACE)
+    array = np.asarray(value, dtype=np.float64).ravel()
+    if array.size == 0:
+        raise ValueError("No values given")
+    return array
+
+
+def load_array(path) -> np.ndarray:
+    """Load ``.npy`` or delimited text as a float array."""
+    path = Path(path)
+    if path.suffix.lower() == ".npy":
+        return np.load(path)
+    text = path.read_text("utf-8")
+    delimiter = "," if "," in text.splitlines()[0] else None
+    return np.loadtxt(path, delimiter=delimiter, ndmin=1)
+
+
+def values_from(text: str) -> np.ndarray:
+    """``parse_values`` unless ``text`` names an existing file."""
+    text = text.strip()
+    if text and Path(text).is_file():
+        return load_array(text).ravel()
+    return parse_values(text)
+
+
+def check_precision(inputs: dict, precision) -> tuple:
+    """``(errors, warnings)`` for values that overflow or merge in ``precision``."""
+    errors, warnings = [], []
+    name = np.dtype(precision).name
+    with np.errstate(over="ignore"):
+        for label, values in inputs.items():
+            cast = np.asarray(values, dtype=precision)
+            bad = int(np.count_nonzero(~np.isfinite(cast)))
+            if bad:
+                errors.append(f"{label}: {bad} of {cast.size} values "
+                              f"overflow {name}")
+                continue
+            distinct = np.unique(cast).size
+            if distinct < cast.size:
+                warnings.append(f"{label}: {cast.size} values are "
+                                f"{distinct} distinct in {name}")
+    return errors, warnings
+
+
+def input_dict(rows) -> dict:
+    """``{name: values}`` from ``(name, text)`` rows, skipping blanks."""
+    out = {}
+    for name, text in rows:
+        if text.strip():
+            out[name] = values_from(text)
+    return out
+
+
+def single_value(text: str, name: str = "") -> float:
+    """One float from a number or expression; sweeps are refused by name."""
+    try:
+        array = parse_values(text)
+    except ValueError as error:
+        raise ValueError(f"{name}: {error}" if name else str(error))
+    if array.size != 1:
+        raise ValueError(
+            f"{name or text}: {array.size} values given but this field "
+            "takes one number; sweeps go in a values column"
+        )
+    return float(array[0])
+
+
+def final_states(path, run: int) -> dict:
+    """``{saved variable: value}`` at the last sample of ``run``."""
+    return Store(path).final_values(run)
+
+
+def make_driver_samples(columns: dict, time_text: str = "",
+                        t0: float = 0.0, period: float = 0.0):
+    """A ``DriverSamples`` from per-driver texts and a time base.
+
+    Parameters
+    ----------
+    columns
+        Driver name to value text or data file path.
+    time_text
+        Sample times; empty uses ``t0`` and ``period``.
+    """
+    samples = {name: values_from(text) for name, text in columns.items()}
+    if not samples:
+        return None
+    if time_text.strip():
+        return DriverSamples(samples, time=values_from(time_text))
+    return DriverSamples(samples, driver_sample_period=period, t0=t0)

cubievis-0.0.1/src/cubievis/jobs.py

@@ -0,0 +1,116 @@
+"""One worker thread runs every cubie call; the GUI polls its jobs."""
+
+import queue
+import threading
+import time
+import traceback
+import warnings
+
+import attrs
+
+from cubie import default_timelogger
+
+# Event-name prefix to the phase label shown while it is running.
+PHASES = (
+    ("symbolic_ode_parsing", "Parsing"),
+    ("codegen", "Generating code"),
+    ("compile", "Compiling"),
+    ("solver_solve", "Solving"),
+    ("solve_ivp", "Solving"),
+)
+
+
+@attrs.define
+class Job:
+    """A queued call and everything it produced."""
+
+    fn: object
+    args: tuple = ()
+    kwargs: dict = attrs.field(factory=dict)
+    label: str = ""
+    state: str = "queued"
+    result: object = None
+    error: str = ""
+    warnings: list = attrs.field(factory=list)
+    started: float = 0.0
+    finished: float = 0.0
+
+    @property
+    def done(self) -> bool:
+        return self.state in ("done", "failed")
+
+    @property
+    def elapsed(self) -> float:
+        end = self.finished or time.perf_counter()
+        return end - self.started if self.started else 0.0
+
+
+def phase_label(name: str) -> str:
+    """Phase label for a timelogger event name, or the name itself."""
+    for prefix, label in PHASES:
+        if name.startswith(prefix):
+            return label
+    return name
+
+
+def current_phase(logger=default_timelogger):
+    """``(label, start_timestamp)`` of the innermost open event, or None."""
+    stopped = set()
+    for event in reversed(logger.events):
+        if event.event_type == "stop":
+            stopped.add(event.name)
+        elif event.event_type == "start" and event.name not in stopped:
+            return phase_label(event.name), event.timestamp
+    return None
+
+
+def status_line(job: Job) -> str:
+    """``"Compiling (3s)"``-style line for the job's current phase."""
+    if job.state == "queued":
+        return f"{job.label} queued"
+    if job.state == "failed":
+        return f"{job.label} failed ({job.elapsed:.0f}s)"
+    if job.state == "done":
+        return f"{job.label} done ({job.elapsed:.0f}s)"
+    phase = current_phase()
+    if phase is None:
+        return f"{job.label} ({job.elapsed:.0f}s)"
+    label, started = phase
+    return f"{label} ({time.perf_counter() - started:.0f}s)"
+
+
+class CubieWorker(threading.Thread):
+    """Daemon thread executing jobs one at a time, in submission order."""
+
+    def __init__(self):
+        super().__init__(daemon=True, name="cubie-worker")
+        self._queue = queue.Queue()
+        self.current = None
+        default_timelogger.set_verbosity("silent")
+
+    def submit(self, fn, *args, label="", **kwargs) -> Job:
+        """Queue ``fn(*args, **kwargs)`` and return its job."""
+        job = Job(fn=fn, args=args, kwargs=kwargs, label=label or fn.__name__)
+        self._queue.put(job)
+        return job
+
+    def run(self):
+        while True:
+            job = self._queue.get()
+            self.current = job
+            job.state = "running"
+            job.started = time.perf_counter()
+            with warnings.catch_warnings(record=True) as caught:
+                warnings.simplefilter("always")
+                try:
+                    job.result = job.fn(*job.args, **job.kwargs)
+                    job.state = "done"
+                except Exception:
+                    job.error = traceback.format_exc()
+                    job.state = "failed"
+            job.warnings = list(dict.fromkeys(
+                str(item.message) for item in caught
+                if not issubclass(item.category, DeprecationWarning)
+            ))
+            job.finished = time.perf_counter()
+            self.current = None

cubievis-0.0.1/src/cubievis/picks.py

@@ -0,0 +1,84 @@
+"""Picked points: the run and sample a click hit, where it sits in a frame, its values."""
+
+import attrs
+import numpy as np
+
+from cubievis.view_model import TIME, kind, label, ref_name, ref_order
+
+
+@attrs.frozen
+class Pick:
+    """One data point: ``run`` at sample ``index`` of the store's time."""
+
+    run: int
+    index: int
+
+
+def nearest_index(times, t) -> int:
+    """Index of the value in sorted ``times`` closest to ``t``."""
+    i = int(np.searchsorted(times, t))
+    if i <= 0:
+        return 0
+    if i >= len(times):
+        return len(times) - 1
+    return i if times[i] - t < t - times[i - 1] else i - 1
+
+
+def pick_at(store, plan, geo, frame: int, line: int, point: int) -> Pick:
+    """The data point drawn at vertex ``point`` of ``line`` in ``frame``."""
+    runs = geo.runs[frame][line]
+    if plan.along == TIME:
+        return Pick(int(runs[0]), nearest_index(store.time, geo.times[point]))
+    return Pick(int(runs[min(point, len(runs) - 1)]),
+                geo.time_indices[frame])
+
+
+def locate(store, plan, geo, frame: int, pick: Pick):
+    """``(line, point)`` of ``pick`` in ``frame``, or ``None`` when it is not drawn there."""
+    line = next((i for i, runs in enumerate(geo.runs[frame])
+                 if pick.run in runs), None)
+    if line is None:
+        return None
+    if plan.along == TIME:
+        return line, nearest_index(geo.times, store.time[pick.index])
+    if geo.time_indices[frame] != pick.index:
+        return None
+    runs = list(geo.runs[frame][line])
+    return line, runs.index(pick.run)
+
+
+def values_at(store, plan, pick: Pick) -> dict:
+    """``{role: data value}`` of ``pick`` on each plotted axis."""
+    out = {}
+    for role, ref in plan.roles.items():
+        if ref == TIME:
+            out[role] = float(store.time[pick.index])
+        elif kind(ref) == "var":
+            out[role] = float(store.at(ref_name(ref), [pick.run], pick.index,
+                                       ref_order(ref))[0])
+        else:
+            out[role] = float(store.inputs[ref_name(ref)][pick.run])
+    return out
+
+
+def world_point(geo, values: dict) -> np.ndarray:
+    """World ``(x, y, z)`` of ``values``; z is 0 on a 2D plot."""
+    point = np.zeros(3, np.float32)
+    for axis, role in enumerate(("x", "y", "z")):
+        if role in values:
+            point[axis] = geo.transforms[role].world(values[role])
+    return point
+
+
+def flag_text(plan, pick: Pick, values: dict) -> str:
+    """The run and each axis value, one per line."""
+    lines = [f"run {pick.run}"]
+    lines += [f"{label(ref)} {values[role]:.4g}"
+              for role, ref in plan.roles.items()]
+    return "\n".join(lines)
+
+
+def state_at(store, pick: Pick) -> dict:
+    """``{saved variable: value}`` of ``pick``."""
+    return {name: float(store.raw(name)[pick.run, pick.index])
+            for name in store.variables}