bernardyn 0.0.1b1__tar.gz

bernardyn-0.0.1b1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jan Ilavsky and Bernardyn contributors
+
+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.

bernardyn-0.0.1b1/PKG-INFO

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: bernardyn
+Version: 0.0.1b1
+Summary: Publication-oriented plotting workbench for small-angle scattering data
+Author: Jan Ilavsky
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/jilavsky/Bernardyn
+Project-URL: Repository, https://github.com/jilavsky/Bernardyn
+Project-URL: Issues, https://github.com/jilavsky/Bernardyn/issues
+Keywords: SAXS,SANS,USAXS,WAXS,scattering,visualization
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: <3.14,>=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=2.0
+Requires-Dist: h5py>=3.0
+Requires-Dist: PyOpenGL>=3.1.7
+Requires-Dist: pyirena[qtplot]<2,>=1.1.0b12
+Requires-Dist: pyqtgraph>=0.13.7
+Requires-Dist: PySide6!=6.9.1,>=6.8
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-qt>=4.2; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+
+# Bernardyn
+
+Bernardyn is a PySide6/PyQtGraph workbench for publication-oriented plotting of
+small-angle scattering and diffraction curves. It keeps scientific arrays out
+of widgets and stores complete, source-independent graphs in portable HDF5
+packages.
+
+## Current capabilities
+
+- Browse all discoverable NXcanSAS/simple-HDF5 entries and 2–4 column text data.
+- Keep a workspace-wide dataset catalog and independent graph tabs.
+- Plot General I(Q), Guinier, rod/sheet Guinier, Kratky, dimensionless Kratky,
+  Porod, modified Porod, Zimm, and Debye–Bueche views.
+- Style each curve, errors, labels, axes, legends, typography, and annotations.
+- Render 3D line waterfalls and common-grid surfaces with an isolated,
+  lazily-loaded PyQtGraph OpenGL backend and 2D fallback.
+- Save one graph or a deduplicated multi-graph workspace as
+  `*.bernardyn.h5`, including canonical data, resolved snapshots, configuration,
+  checksums, previews, and 3D renderer data.
+- Export PNG/JPEG/SVG, CSV, Igor ITX, and canonical data through PyIrena's H5XP
+  writer. H5XP export is data interoperability, not Bernardyn graph persistence.
+
+The native schema is documented in
+[`bernardyn/schemas/graph-package-v1.md`](bernardyn/schemas/graph-package-v1.md).
+User-facing workflow and file-format documentation is in
+[`docs/`](docs/README.md).
+
+## Install and run
+
+Bernardyn targets Python 3.10–3.13 and shares its Qt plotting dependencies with
+PyIrena. For development, keep the `Bernardyn` and `pyirena` repositories next
+to each other and create the pinned Conda environment from the Bernardyn root:
+
+```bash
+conda env create -f environment.yml
+conda activate bernardyn
+bernardyn-doctor
+bernardyn
+```
+
+The environment file installs both repositories in editable mode. If an older
+`bernardyn` environment already exists with Python 3.14, remove and recreate it:
+
+```bash
+conda deactivate
+conda env remove -n bernardyn
+conda env create -f environment.yml
+conda activate bernardyn
+```
+
+For an already compatible Python 3.10–3.13 environment, installation can also
+be performed manually:
+
+```bash
+python -m pip install -e "../pyirena[qtplot]"
+python -m pip install -e ".[dev]"
+bernardyn
+```
+
+To diagnose an installation:
+
+```bash
+bernardyn-doctor
+bernardyn-doctor --json
+```
+
+The OpenGL renderer needs a usable graphics context. If it cannot initialize,
+Bernardyn displays a 2D offset-waterfall fallback and retains the 3D document
+configuration.
+
+## Development
+
+```bash
+pytest
+ruff check bernardyn tests
+python -m build
+twine check dist/*
+```
+
+Extension entry points are `bernardyn.sources`, `bernardyn.transforms`, and
+`bernardyn.renderers`; see [`bernardyn/EXTENDING.md`](bernardyn/EXTENDING.md).
+
+## Scope
+
+Version 1.0 is a plotting and presentation application. Model fitting,
+reduction, destructive source modification, movies, and calibrated 2D detector
+workflows are intentionally outside 1.0. Existing experimental 0.1 containers
+are not treated as compatible graph packages.
+
+Bernardyn is distributed under the MIT License.

bernardyn-0.0.1b1/README.md

@@ -0,0 +1,90 @@
+# Bernardyn
+
+Bernardyn is a PySide6/PyQtGraph workbench for publication-oriented plotting of
+small-angle scattering and diffraction curves. It keeps scientific arrays out
+of widgets and stores complete, source-independent graphs in portable HDF5
+packages.
+
+## Current capabilities
+
+- Browse all discoverable NXcanSAS/simple-HDF5 entries and 2–4 column text data.
+- Keep a workspace-wide dataset catalog and independent graph tabs.
+- Plot General I(Q), Guinier, rod/sheet Guinier, Kratky, dimensionless Kratky,
+  Porod, modified Porod, Zimm, and Debye–Bueche views.
+- Style each curve, errors, labels, axes, legends, typography, and annotations.
+- Render 3D line waterfalls and common-grid surfaces with an isolated,
+  lazily-loaded PyQtGraph OpenGL backend and 2D fallback.
+- Save one graph or a deduplicated multi-graph workspace as
+  `*.bernardyn.h5`, including canonical data, resolved snapshots, configuration,
+  checksums, previews, and 3D renderer data.
+- Export PNG/JPEG/SVG, CSV, Igor ITX, and canonical data through PyIrena's H5XP
+  writer. H5XP export is data interoperability, not Bernardyn graph persistence.
+
+The native schema is documented in
+[`bernardyn/schemas/graph-package-v1.md`](bernardyn/schemas/graph-package-v1.md).
+User-facing workflow and file-format documentation is in
+[`docs/`](docs/README.md).
+
+## Install and run
+
+Bernardyn targets Python 3.10–3.13 and shares its Qt plotting dependencies with
+PyIrena. For development, keep the `Bernardyn` and `pyirena` repositories next
+to each other and create the pinned Conda environment from the Bernardyn root:
+
+```bash
+conda env create -f environment.yml
+conda activate bernardyn
+bernardyn-doctor
+bernardyn
+```
+
+The environment file installs both repositories in editable mode. If an older
+`bernardyn` environment already exists with Python 3.14, remove and recreate it:
+
+```bash
+conda deactivate
+conda env remove -n bernardyn
+conda env create -f environment.yml
+conda activate bernardyn
+```
+
+For an already compatible Python 3.10–3.13 environment, installation can also
+be performed manually:
+
+```bash
+python -m pip install -e "../pyirena[qtplot]"
+python -m pip install -e ".[dev]"
+bernardyn
+```
+
+To diagnose an installation:
+
+```bash
+bernardyn-doctor
+bernardyn-doctor --json
+```
+
+The OpenGL renderer needs a usable graphics context. If it cannot initialize,
+Bernardyn displays a 2D offset-waterfall fallback and retains the 3D document
+configuration.
+
+## Development
+
+```bash
+pytest
+ruff check bernardyn tests
+python -m build
+twine check dist/*
+```
+
+Extension entry points are `bernardyn.sources`, `bernardyn.transforms`, and
+`bernardyn.renderers`; see [`bernardyn/EXTENDING.md`](bernardyn/EXTENDING.md).
+
+## Scope
+
+Version 1.0 is a plotting and presentation application. Model fitting,
+reduction, destructive source modification, movies, and calibrated 2D detector
+workflows are intentionally outside 1.0. Existing experimental 0.1 containers
+are not treated as compatible graph packages.
+
+Bernardyn is distributed under the MIT License.

bernardyn-0.0.1b1/bernardyn/__init__.py

@@ -0,0 +1,23 @@
+"""Bernardyn scientific plotting workbench."""
+
+from bernardyn.core.models import (
+    Annotation,
+    Dataset,
+    DatasetKind,
+    GraphDocument,
+    PlotSeries,
+    SeriesView,
+    Workspace,
+)
+
+__all__ = [
+    "Annotation",
+    "Dataset",
+    "DatasetKind",
+    "GraphDocument",
+    "PlotSeries",
+    "SeriesView",
+    "Workspace",
+]
+
+__version__ = "0.0.1b1"

bernardyn-0.0.1b1/bernardyn/app.py

@@ -0,0 +1,31 @@
+"""GUI application entry point."""
+
+from __future__ import annotations
+
+import logging
+import os
+import sys
+
+from PySide6.QtWidgets import QApplication
+
+from bernardyn.gui.main_window import MainWindow
+
+
+def main() -> int:
+    # BERNARDYN_LOG_LEVEL=DEBUG turns on the per-annotation placement trace
+    # and the renderer's coordinate diagnostics.
+    level = os.environ.get("BERNARDYN_LOG_LEVEL", "INFO").upper()
+    logging.basicConfig(
+        level=getattr(logging, level, logging.INFO),
+        format="%(levelname)s %(name)s: %(message)s",
+    )
+    app = QApplication.instance() or QApplication(sys.argv)
+    app.setApplicationName("Bernardyn")
+    app.setOrganizationName("Bernardyn")
+    window = MainWindow()
+    window.show()
+    return app.exec()
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

bernardyn-0.0.1b1/bernardyn/core/__init__.py

@@ -0,0 +1,6 @@
+"""Scientific domain models, transforms, registries, and workspace logic."""
+
+from bernardyn.core.models import *  # noqa: F403
+from bernardyn.core.transforms import TransformRegistry, builtin_transforms
+
+__all__ = ["TransformRegistry", "builtin_transforms"]

bernardyn-0.0.1b1/bernardyn/core/controller.py

@@ -0,0 +1,319 @@
+"""Qt-independent application controller for workspaces and graph packages."""
+
+from __future__ import annotations
+
+from dataclasses import replace
+from pathlib import Path
+from typing import Any, Iterable, Mapping
+
+from bernardyn.core.models import (
+    Dataset,
+    GraphDocument,
+    PlotSeries,
+    SeriesStyle,
+    SeriesView,
+    Workspace,
+)
+from bernardyn.core.transforms import TransformRegistry, builtin_transforms, resolve_series
+from bernardyn.io.container import LoadedPackage, import_graphs, load_package, save_package
+from bernardyn.io.sources import ScatteringLocation, SourceRegistry, builtin_sources
+
+PALETTE = (
+    (31, 119, 180, 255),
+    (214, 39, 40, 255),
+    (44, 160, 44, 255),
+    (148, 103, 189, 255),
+    (255, 127, 14, 255),
+    (23, 190, 207, 255),
+    (140, 86, 75, 255),
+    (227, 119, 194, 255),
+)
+
+
+class ApplicationController:
+    def __init__(
+        self,
+        *,
+        transforms: TransformRegistry | None = None,
+        sources: SourceRegistry | None = None,
+    ) -> None:
+        self.transforms = transforms or builtin_transforms()
+        self.sources = sources or builtin_sources()
+        self.workspace = Workspace()
+        self.snapshots: dict[str, dict[str, PlotSeries]] = {}
+        self.previews: dict[str, bytes] = {}
+        self.renderer_data: dict[str, dict[str, Any]] = {}
+        self.read_only_graphs: set[str] = set()
+        self.preview_only_graphs: set[str] = set()
+        self._graph_warnings: dict[str, list[str]] = {}
+        self.package_path: Path | None = None
+        self.warnings: list[str] = []
+        self.new_graph()
+
+    def new_workspace(self, title: str = "Untitled workspace") -> None:
+        self.workspace = Workspace(title=title)
+        self.snapshots.clear()
+        self.previews.clear()
+        self.renderer_data.clear()
+        self.read_only_graphs.clear()
+        self.preview_only_graphs.clear()
+        self._graph_warnings.clear()
+        self.package_path = None
+        self.warnings.clear()
+        self.new_graph()
+
+    def new_graph(self, renderer_id: str = "plot2d", title: str | None = None) -> GraphDocument:
+        number = len(self.workspace.graphs) + 1
+        graph = GraphDocument(
+            title=title or f"Scattering plot {number}",
+            renderer_id=renderer_id,
+            renderer_config={
+                "mode": "surface" if renderer_id == "opengl_surface" else "waterfall",
+                "renderer_version": "1.0",
+                "spacing": 1.0,
+                "normalization": "none",
+                "surface_samples": 512,
+                "series_axis_key": "",
+                "series_positions": {},
+                "projection": "perspective",
+                "show_grid": True,
+                "camera": {"distance": 40.0, "elevation": 25.0, "azimuth": -45.0},
+            }
+            if renderer_id.startswith("opengl")
+            else {"renderer_version": "1.0"},
+        )
+        self.workspace.add_graph(graph)
+        self.snapshots[graph.id] = {}
+        return graph
+
+    def close_graph(self, graph_id: str) -> None:
+        self.workspace.graphs = [graph for graph in self.workspace.graphs if graph.id != graph_id]
+        self.snapshots.pop(graph_id, None)
+        self.previews.pop(graph_id, None)
+        self.renderer_data.pop(graph_id, None)
+        self.read_only_graphs.discard(graph_id)
+        self.preview_only_graphs.discard(graph_id)
+        self._graph_warnings.pop(graph_id, None)
+        if not self.workspace.graphs:
+            self.new_graph()
+        self.workspace.active_graph_id = self.workspace.graphs[-1].id
+        self.workspace.dirty = True
+
+    def add_dataset(self, dataset: Dataset, *, graph_id: str | None = None) -> SeriesView:
+        self.workspace.add_dataset(dataset)
+        graph = self.workspace.graph(graph_id or self.workspace.active_graph_id or "")
+        series = SeriesView(
+            dataset_id=dataset.id,
+            legend_label=dataset.label,
+            style=SeriesStyle(color=PALETTE[len(graph.series) % len(PALETTE)]),
+        )
+        self.workspace.replace_graph(graph.replace_series((*graph.series, series)))
+        self.recompute_graph(graph.id)
+        return series
+
+    def load_location(
+        self,
+        location: ScatteringLocation,
+        *,
+        graph_id: str | None = None,
+        q_unit: str = "1/A",
+        error_fraction: float = 0.05,
+    ) -> Dataset:
+        record = self.sources.load_location(
+            location, q_unit=q_unit, error_fraction=error_fraction
+        )
+        dataset = record.to_dataset()
+        self.add_dataset(dataset, graph_id=graph_id)
+        return dataset
+
+    def update_graph(self, graph: GraphDocument, *, recompute: bool = False) -> None:
+        if graph.id in self.read_only_graphs:
+            raise PermissionError("this graph is read-only because its canonical data are invalid")
+        self.workspace.replace_graph(graph)
+        if recompute:
+            self.recompute_graph(graph.id)
+
+    def recompute_graph(self, graph_id: str) -> dict[str, PlotSeries]:
+        if graph_id in self.read_only_graphs:
+            raise PermissionError("cannot recompute a graph with invalid canonical data")
+        graph = self.workspace.graph(graph_id)
+        resolved: dict[str, PlotSeries] = {}
+        for view in graph.series:
+            dataset = self.workspace.datasets[view.dataset_id]
+            resolved[view.id] = resolve_series(
+                dataset,
+                view,
+                self.transforms,
+                x_log=graph.x_axis.log,
+                y_log=graph.y_axis.log,
+            )
+        self.snapshots[graph_id] = resolved
+        self._graph_warnings[graph_id] = [
+            warning
+            for warning in self._graph_warnings.get(graph_id, [])
+            if "current version" not in warning and "was recomputed" not in warning
+        ]
+        self.workspace.dirty = True
+        return resolved
+
+    def set_transform(
+        self,
+        graph_id: str,
+        transform_id: str,
+        parameters: Mapping[str, float] | None = None,
+    ) -> None:
+        graph = self.workspace.graph(graph_id)
+        transform = self.transforms.get(transform_id)
+        series = tuple(
+            replace(
+                item,
+                transform_id=transform_id,
+                transform_parameters=dict(parameters or {}),
+            )
+            for item in graph.series
+        )
+        graph = replace(
+            graph,
+            series=series,
+            x_axis=replace(
+                graph.x_axis,
+                label=transform.default_x_label,
+                log=transform.default_x_log,
+                auto_range=True,
+            ),
+            y_axis=replace(
+                graph.y_axis,
+                label=transform.default_y_label,
+                log=transform.default_y_log,
+                auto_range=True,
+            ),
+        )
+        self.update_graph(graph, recompute=True)
+
+    def remove_series(self, graph_id: str, series_id: str) -> None:
+        graph = self.workspace.graph(graph_id)
+        self.update_graph(
+            graph.replace_series(item for item in graph.series if item.id != series_id),
+            recompute=True,
+        )
+
+    def move_series(self, graph_id: str, series_id: str, offset: int) -> None:
+        graph = self.workspace.graph(graph_id)
+        items = list(graph.series)
+        old = next(index for index, item in enumerate(items) if item.id == series_id)
+        new = max(0, min(len(items) - 1, old + offset))
+        items.insert(new, items.pop(old))
+        self.update_graph(graph.replace_series(items), recompute=False)
+
+    def open_package(self, path: str | Path) -> LoadedPackage:
+        loaded = load_package(path)
+        self.workspace = loaded.workspace
+        self.snapshots = loaded.snapshots
+        self.previews = loaded.previews
+        self.renderer_data = loaded.renderer_data
+        self.read_only_graphs = loaded.read_only_graphs
+        self.preview_only_graphs.clear()
+        self._graph_warnings.clear()
+        self.package_path = loaded.path
+        self.warnings = loaded.warnings
+        recovered = False
+        for graph in self.workspace.graphs:
+            graph_warnings = self._graph_warnings.setdefault(graph.id, [])
+            for view in graph.series:
+                archived = self.snapshots.get(graph.id, {}).get(view.id)
+                try:
+                    transform = self.transforms.get(view.transform_id)
+                except KeyError:
+                    graph_warnings.append(
+                        f"Unknown transform {view.transform_id!r}; showing the archived preview when available"
+                    )
+                    if graph.id in self.previews:
+                        self.preview_only_graphs.add(graph.id)
+                    continue
+                if archived is not None and archived.transform_version != transform.version:
+                    graph_warnings.append(
+                        f"{transform.name} snapshot uses version {archived.transform_version}; "
+                        f"current version is {transform.version}. Use Recompute with Current Version explicitly."
+                    )
+                    continue
+                if archived is None:
+                    dataset = self.workspace.datasets[view.dataset_id]
+                    self.snapshots.setdefault(graph.id, {})[view.id] = resolve_series(
+                        dataset,
+                        view,
+                        self.transforms,
+                        x_log=graph.x_axis.log,
+                        y_log=graph.y_axis.log,
+                    )
+                    graph_warnings.append(
+                        f"Missing or corrupt snapshot for {dataset.label!r} was recomputed from embedded data"
+                    )
+                    recovered = True
+        if recovered:
+            self.workspace.dirty = True
+        return loaded
+
+    def import_from_package(
+        self, path: str | Path, graph_ids: Iterable[str] | None = None
+    ) -> dict[str, str]:
+        loaded = load_package(path)
+        selected = list(graph_ids) if graph_ids is not None else [g.id for g in loaded.workspace.graphs]
+        graph_map, snapshots = import_graphs(self.workspace, loaded, selected)
+        self.snapshots.update(snapshots)
+        for old_id, new_id in graph_map.items():
+            if old_id in loaded.previews:
+                self.previews[new_id] = loaded.previews[old_id]
+            if old_id in loaded.renderer_data:
+                self.renderer_data[new_id] = loaded.renderer_data[old_id]
+            if old_id in loaded.read_only_graphs:
+                self.read_only_graphs.add(new_id)
+        self.warnings.extend(loaded.warnings)
+        return graph_map
+
+    def save(
+        self,
+        path: str | Path | None = None,
+        *,
+        graph_ids: Iterable[str] | None = None,
+        previews: Mapping[str, bytes] | None = None,
+        renderer_data: Mapping[str, Mapping[str, Any]] | None = None,
+    ) -> Path:
+        destination = Path(path) if path is not None else self.package_path
+        if destination is None:
+            raise ValueError("a destination path is required for the first save")
+        chosen = list(graph_ids) if graph_ids is not None else None
+        selected_graph_ids = chosen or [graph.id for graph in self.workspace.graphs]
+        read_only = self.read_only_graphs.intersection(selected_graph_ids)
+        if read_only:
+            raise PermissionError(
+                "cannot save graphs whose canonical arrays failed validation; "
+                "retain the original package as the archival copy"
+            )
+        for graph_id in selected_graph_ids:
+            graph = self.workspace.graph(graph_id)
+            missing = [
+                series.id
+                for series in graph.series
+                if series.id not in self.snapshots.get(graph_id, {})
+            ]
+            if missing and graph_id not in self.read_only_graphs:
+                self.recompute_graph(graph_id)
+        saved = save_package(
+            destination,
+            self.workspace,
+            self.snapshots,
+            graph_ids=chosen,
+            previews=previews or self.previews,
+            renderer_data=renderer_data or self.renderer_data,
+        )
+        if chosen is None:
+            self.package_path = saved
+            self.workspace.dirty = False
+        return saved
+
+    def graph_warnings(self, graph_id: str) -> list[str]:
+        return self._graph_warnings.get(graph_id, []) + [
+            warning
+            for snapshot in self.snapshots.get(graph_id, {}).values()
+            for warning in snapshot.warnings
+        ]