plopp 25.6.0__tar.gz → 25.7.0__tar.gz

{plopp-25.6.0 → plopp-25.7.0}/.github/workflows/release.yml

@@ -5,34 +5,7 @@ on:
     types: [published]
   workflow_dispatch:
 
-defaults:
-  run:
-    shell: bash -l {0}  # required for conda env
-
 jobs:
-  build_conda:
-    name: Conda build
-    runs-on: 'ubuntu-24.04'
-
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: true
-          fetch-depth: 0  # history required so setuptools_scm can determine version
-
-      - uses: mamba-org/setup-micromamba@v1
-        with:
-          environment-name: build-env
-          create-args: >-
-            conda-build
-            boa
-      - run: conda mambabuild --channel conda-forge --channel scipp --no-anaconda-upload --override-channels --output-folder conda/package conda
-
-      - uses: actions/upload-artifact@v4
-        with:
-          name: conda-package-noarch
-          path: conda/package/noarch/*.tar.bz2
-
   build_wheels:
     name: Wheels
     runs-on: 'ubuntu-24.04'
@@ -60,7 +33,7 @@ jobs:
 
   upload_pypi:
     name: Deploy PyPI
-    needs: [build_wheels, build_conda]
+    needs: build_wheels
     runs-on: 'ubuntu-24.04'
     environment: release
     permissions:
@@ -70,25 +43,8 @@ jobs:
       - uses: actions/download-artifact@v4
       - uses: pypa/gh-action-pypi-publish@v1.12.4
 
-  upload_conda:
-    name: Deploy Conda
-    needs: [build_wheels, build_conda]
-    runs-on: 'ubuntu-24.04'
-    if: github.event_name == 'release' && github.event.action == 'published'
-
-    steps:
-      - uses: actions/download-artifact@v4
-      - uses: mamba-org/setup-micromamba@v1
-        with:
-          environment-name: upload-env
-          # frozen python due to breaking removal of 'imp' in 3.12
-          create-args: >-
-            anaconda-client
-            python=3.11
-      - run: anaconda --token ${{ secrets.ANACONDATOKEN }} upload --user scipp --label main $(ls conda-package-noarch/*.tar.bz2)
-
   docs:
-    needs: [upload_conda, upload_pypi]
+    needs: upload_pypi
     uses: ./.github/workflows/docs.yml
     with:
       publish: ${{ github.event_name == 'release' && github.event.action == 'published' }}

{plopp-25.6.0 → plopp-25.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plopp
-Version: 25.6.0
+Version: 25.7.0
 Summary: Visualization library for Scipp
 Author: Scipp contributors
 License: BSD 3-Clause License
@@ -84,7 +84,7 @@ Dynamic: license-file
 
 [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg)](CODE_OF_CONDUCT.md)
 [![PyPI badge](http://img.shields.io/pypi/v/plopp.svg)](https://pypi.python.org/pypi/plopp)
-[![Anaconda-Server Badge](https://anaconda.org/scipp/plopp/badges/version.svg)](https://anaconda.org/scipp/plopp)
+[![Anaconda-Server Badge](https://anaconda.org/conda-forge/plopp/badges/version.svg)](https://anaconda.org/conda-forge/plopp)
 [![Documentation](https://img.shields.io/badge/docs-online-success)](https://scipp.github.io/plopp/)
 [![License: BSD 3-Clause](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](LICENSE)
 [![DOI](https://zenodo.org/badge/528859752.svg)](https://zenodo.org/badge/latestdoi/528859752)

{plopp-25.6.0 → plopp-25.7.0}/README.md

@@ -2,7 +2,7 @@
 
 [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg)](CODE_OF_CONDUCT.md)
 [![PyPI badge](http://img.shields.io/pypi/v/plopp.svg)](https://pypi.python.org/pypi/plopp)
-[![Anaconda-Server Badge](https://anaconda.org/scipp/plopp/badges/version.svg)](https://anaconda.org/scipp/plopp)
+[![Anaconda-Server Badge](https://anaconda.org/conda-forge/plopp/badges/version.svg)](https://anaconda.org/conda-forge/plopp)
 [![Documentation](https://img.shields.io/badge/docs-online-success)](https://scipp.github.io/plopp/)
 [![License: BSD 3-Clause](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](LICENSE)
 [![DOI](https://zenodo.org/badge/528859752.svg)](https://zenodo.org/badge/latestdoi/528859752)

{plopp-25.6.0 → plopp-25.7.0}/docs/gallery/streaming-plot.ipynb

@@ -125,7 +125,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Display figure a play widget\n",
+    "# Display figure and play widget\n",
     "ipw.VBox([fig, play])"
    ]
   },
@@ -154,7 +154,12 @@
    "execution_count": null,
    "id": "10",
    "metadata": {
-    "nbsphinx": "hidden"
+    "editable": true,
+    "nbsphinx": "hidden",
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
    },
    "outputs": [],
    "source": [
@@ -162,6 +167,147 @@
     "# It is hidden from the online documentation.\n",
     "fig.save('../_static/gallery/streaming-plot-thumbnail.png')"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "11",
+   "metadata": {},
+   "source": [
+    "## Streaming on a 3D figure\n",
+    "\n",
+    "The same works for 3D scatter plots.\n",
+    "\n",
+    "We make a slightly different data generator:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "12",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "class DataGen:\n",
+    "    \"\"\"A data generator which makes new data on a cylindrical detector panel\"\"\"\n",
+    "    def __init__(self):\n",
+    "        nphi = 100\n",
+    "        nz = 20\n",
+    "\n",
+    "        r = sc.scalar(10.0, unit='m')\n",
+    "        phi = sc.linspace('phi', 0, np.pi, nphi + 1, unit='rad')\n",
+    "        z = sc.linspace('z', -3.0, 3.0, nz + 1, unit='m')\n",
+    "\n",
+    "        p = sc.midpoints(phi)\n",
+    "        x = r * sc.cos(p)\n",
+    "        y = r * sc.sin(p)\n",
+    "        sizes = {'z': nz, 'phi': nphi}\n",
+    "\n",
+    "        self.data = sc.DataArray(\n",
+    "            data=sc.zeros(sizes=sizes, unit='counts'),\n",
+    "            coords={\n",
+    "                'z': z,\n",
+    "                'phi': phi,\n",
+    "                'position': sc.spatial.as_vectors(\n",
+    "                    sc.broadcast(x, sizes=sizes),\n",
+    "                    sc.broadcast(sc.midpoints(z), sizes=sizes),\n",
+    "                    sc.broadcast(y, sizes=sizes)\n",
+    "                ),\n",
+    "            },\n",
+    "        )\n",
+    "\n",
+    "    def __call__(self, iteration: int=0):\n",
+    "        # Generate new data when called\n",
+    "        npoints = 100\n",
+    "        phi = sc.array(dims=['event'], values=np.random.normal(scale=0.5, loc=0.5*np.pi, size=npoints), unit='rad')\n",
+    "        z = sc.array(dims=['event'], values=np.random.normal(scale=2, size=npoints), unit='m')\n",
+    "        new_events = sc.DataArray(\n",
+    "            data=sc.ones(sizes=phi.sizes, unit=\"counts\"),\n",
+    "            coords={'phi': phi, 'z': z})\n",
+    "        # Histogram and add to container\n",
+    "        self.data += new_events.hist({x: self.data.coords[x] for x in (\"phi\", \"z\")})\n",
+    "        return self.data\n",
+    "\n",
+    "data = DataGen()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "13",
+   "metadata": {},
+   "source": [
+    "We then connect the streaming node to a 3D scatter plot:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "14",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "play = ipw.Play(min=0, max=500, interval=100)\n",
+    "play_node = pp.widget_node(play)\n",
+    "stream_node = pp.Node(data, iteration=play_node)\n",
+    "fig = pp.scatter3d(stream_node, pos='position', cbar=True, pixel_size=0.3, autoscale=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "15",
+   "metadata": {
+    "editable": true,
+    "nbsphinx": "hidden",
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "for _ in range(500):\n",
+    "    play_node.notify_children(\"update\")\n",
+    "fig.view.fit_to_data()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "16",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Display figure and play widget\n",
+    "ipw.VBox([fig, play])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "17",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pp.show_graph(fig)"
+   ]
   }
  ],
  "metadata": {

{plopp-25.6.0 → plopp-25.7.0}/docs/plotting/slicer-plot.ipynb

@@ -61,6 +61,48 @@
    "source": [
     "pp.slicer(da, keep=['x'])"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6",
+   "metadata": {},
+   "source": [
+    "## Animate the sliders\n",
+    "\n",
+    "<div class=\"versionadded\" style=\"font-weight: bold;\">\n",
+    "\n",
+    "<img src=\"../_static/circle-exclamation.svg\" width=\"16\" height=\"16\" />\n",
+    "&nbsp;\n",
+    "New in version 25.07.0.\n",
+    "\n",
+    "</div>\n",
+    "\n",
+    "It is possible to display some animation controls (play button) next to the slider,\n",
+    "by using the `enable_player=True` option:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pp.slicer(da, keep=['x', 'y'], enable_player=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8",
+   "metadata": {},
+   "source": [
+    "## Can I have a 3D plot with a slider?\n",
+    "\n",
+    "3D plots are not supported out of the box by the [plopp.slicer](../generated/plopp.slicer.rst) function,\n",
+    "but it is still possible to create them.\n",
+    "\n",
+    "An example in the [gallery](../gallery/scatter3d-with-slider.ipynb) shows you how to do this."
+   ]
   }
  ],
  "metadata": {

{plopp-25.6.0 → plopp-25.7.0}/docs/plotting/super-plot.ipynb

@@ -57,7 +57,7 @@
    "source": [
     "tool = p.right_bar[0]\n",
     "b = tool.button\n",
-    "sl = p.bottom_bar[0].controls['y']['slider']\n",
+    "sl = p.bottom_bar[0].controls['y']\n",
     "b.click()\n",
     "sl.value = 20\n",
     "b.click()\n",
@@ -102,8 +102,7 @@
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.9"
+   "pygments_lexer": "ipython3"
   }
  },
  "nbformat": 4,

{plopp-25.6.0 → plopp-25.7.0}/src/plopp/core/graph.py

@@ -23,8 +23,8 @@ def _make_graphviz_digraph(*args, **kwargs):
 def _walk_graph(start, nodes, edges, views, labels):
     label = (
         escape(str(start.func)) + '\nid = ' + start.id
-        if start.name is None
-        else escape(start.name)
+        if start.pretty_name is None
+        else escape(start.pretty_name)
     )
     nodes[start.id] = label
     for child in start.children:

{plopp-25.6.0 → plopp-25.7.0}/src/plopp/core/helpers.py

@@ -38,6 +38,6 @@ def widget_node(widget) -> Node:
         ``ipywidgets`` library, or a custom widget.
     """
     n = Node(func=lambda: widget.value)
-    n.name = f'Widget <{type(widget).__name__}: {type(widget.value).__name__}>'
+    n.pretty_name = f'Widget <{type(widget).__name__}: {type(widget.value).__name__}>'
     widget.observe(n.notify_children, names="value")
     return n

{plopp-25.6.0 → plopp-25.7.0}/src/plopp/core/node_class.py

@@ -64,10 +64,10 @@ class Node:
                 )
             )
             fname = getattr(self.func, "__name__", str(self.func))
-            self.name = f'{fname}({args_string})'
+            self.pretty_name = f'{fname}({args_string})'
         else:
             val_str = f'={func!r}' if isinstance(func, int | float | str) else ""
-            self.name = f'Input <{type(func).__name__}{val_str}>'
+            self.pretty_name = f'Input <{type(func).__name__}{val_str}>'
 
         # Attempt to set children after setting name in case error message is needed
         for parent in chain(self.parents, self.kwparents.values()):
@@ -194,7 +194,7 @@ class Node:
         return self.id == other.id
 
     def __repr__(self) -> str:
-        return f"Node(name={self.name})"
+        return f"Node(name={self.pretty_name})"
 
     def __add__(self, other: Node | Any) -> Node:
         return Node(lambda x, y: x + y, self, other)

{plopp-25.6.0 → plopp-25.7.0}/src/plopp/graphics/graphicalview.py

@@ -59,7 +59,7 @@ class GraphicalView(View):
         title: str | None = None,
         figsize: tuple[float, float] | None = None,
         format: Literal['svg', 'png'] | None = None,
-        legend: bool | tuple[float, float] = False,
+        legend: bool | tuple[float, float] = True,
         camera: Camera | None = None,
         autoscale: bool = True,
         ax: Any = None,

{plopp-25.6.0 → plopp-25.7.0}/src/plopp/plotting/common.py

@@ -76,64 +76,28 @@ def to_variable(obj) -> sc.Variable:
     return out
 
 
-def _ensure_data_array_coords(
-    da: sc.DataArray, coords: list[str] | None
-) -> sc.DataArray:
-    if coords is None:
-        coords = list(da.dims)
-    elif missing := set(coords) - set(da.coords.keys()):
-        raise ValueError(f"Specified coords do not exist: {missing}")
-
-    # Remove unused coords
-    da = da.drop_coords(list(set(da.coords) - set(coords)))
-    # Assign dim coords where missing. The above checks ensure that all missing
-    # coords are dim coords, i.e., that `name in out.dims`.
-    da = da.assign_coords(
-        {
-            name: sc.arange(name, da.sizes[name], unit=None)
-            for name in set(coords) - set(da.coords)
-        }
-    )
-    return da
-
-
-def to_data_array(
-    obj: Plottable | list,
-    coords: list[str] | None = None,
-) -> sc.DataArray:
+def to_data_array(obj: Plottable | list) -> sc.DataArray:
     """
-    Convert an input to a DataArray, potentially adding fake coordinates if they are
-    missing.
+    Convert an input to a DataArray.
+    Returns a shallow copy of the input if it is already a DataArray.
 
     Parameters
     ----------
     obj:
         The input object to be converted.
-    coords:
-        If supplied, use these coords instead of the input's dimension coordinates.
     """
+    if isinstance(obj, sc.DataArray):
+        return obj.copy(deep=False)
     out = _maybe_to_variable(obj)
     if isinstance(out, sc.Variable):
         out = sc.DataArray(data=out)
     out = from_compatible_lib(out)
     if not isinstance(out, sc.DataArray):
         raise TypeError(f"Cannot convert input of type {type(obj)} to a DataArray.")
-    out = _ensure_data_array_coords(out, coords)
-    for name, coord in out.coords.items():
-        if not coord.dims:
-            raise ValueError(
-                "Input data cannot be plotted: it has a scalar coordinate along "
-                f"dimension {name}. Consider dropping this coordinate before plotting. "
-                f"Use ``data.drop_coords('{name}').plot()``."
-            )
-    for name in out.coords:
-        other_dims = [dim for dim in out.coords[name].dims if dim not in out.dims]
-        for dim in other_dims:
-            out.coords[name] = out.coords[name].mean(dim)
     return out
 
 
-def _check_size(da: sc.DataArray):
+def _check_size(da: sc.DataArray) -> None:
     """
     Prevent slow figure rendering by raising an error if the data array exceeds a
     default size.
@@ -149,7 +113,7 @@ def _check_size(da: sc.DataArray):
         )
 
 
-def check_not_binned(da: sc.DataArray):
+def check_not_binned(da: sc.DataArray) -> None:
     """
     Plopp cannot plot binned data.
     This function will raise an error if the input data is binned.
@@ -169,7 +133,7 @@ def check_not_binned(da: sc.DataArray):
         )
 
 
-def check_allowed_dtypes(da: sc.DataArray):
+def check_allowed_dtypes(da: sc.DataArray) -> None:
     """
     Currently, Plopp cannot plot data that contains vector and matrix dtypes.
     This function will raise an error if the input data type is not supported.
@@ -185,10 +149,108 @@ def check_allowed_dtypes(da: sc.DataArray):
         )
 
 
-def _all_dims_sorted(var, order='ascending'):
+def _all_dims_sorted(var, order='ascending') -> bool:
+    """
+    Check if all dimensions of a variable are sorted in the specified order.
+    This is used to ensure that the coordinates are sorted before plotting.
+    """
     return all(sc.allsorted(var, dim, order=order) for dim in var.dims)
 
 
+def _rename_dims_from_coords(da: sc.DataArray, coords: Iterable[str]) -> sc.DataArray:
+    """
+    If coordinates are provided, rename the dimensions of the data array to match the
+    names of the coordinates, so that they effectively become the dimension coordinates.
+    """
+    renamed_dims = {}
+    underlying_dims = set()
+    for dim in coords:
+        underlying = da.coords[dim].dims[-1]
+        if underlying in underlying_dims:
+            raise ValueError(
+                "coords: Cannot use more than one coordinate associated with "
+                f"the same underlying dimension ({underlying})."
+            )
+        renamed_dims[underlying] = dim
+        underlying_dims.add(underlying)
+    return da.rename_dims(**renamed_dims)
+
+
+def _add_missing_dimension_coords(da: sc.DataArray) -> sc.DataArray:
+    """
+    Add missing dimension coordinates to the data array.
+    If a dimension does not have a coordinate, it will be added with a range of values.
+    """
+    return da.assign_coords(
+        {
+            dim: sc.arange(dim, da.sizes[dim], unit=None)
+            for dim in da.dims
+            if dim not in da.coords
+        }
+    )
+
+
+def _drop_non_dimension_coords(da: sc.DataArray) -> sc.DataArray:
+    """
+    Drop all coordinates that are not dimension coordinates.
+    This is useful to ensure that only the coordinates that are actually used for
+    plotting are kept.
+    """
+    return da.drop_coords([name for name in da.coords if name not in da.dims])
+
+
+def _handle_coords_with_left_over_dimensions(da: sc.DataArray) -> sc.DataArray:
+    """
+    In some rare cases, the coordinate may have dimensions that are not present in the
+    data array. This can happen for example when a 2d coord with bin edges is sliced
+    along one dimension, leaving a coordinate with the other dimension, and a dimension
+    of length 2 (because of the bin edges) in th sliced dimension.
+
+    This function will handle such cases by averaging the coordinate over the left-over
+    dimensions, effectively reducing the coordinate to a single value for each
+    dimension that is not present in the data array.
+    """
+    return da.assign_coords(
+        {
+            name: da.coords[name].mean(
+                [dim for dim in da.coords[name].dims if dim not in da.dims]
+            )
+            for name in da.coords
+        }
+    )
+
+
+def _check_coord_sanity(da: sc.DataArray) -> None:
+    """
+    Warn if any coordinate is not sorted. This can lead to unpredictable results
+    when plotting.
+    Also, raise an error if any coordinate is scalar.
+    """
+    for name, coord in da.coords.items():
+        try:
+            if not (
+                _all_dims_sorted(coord, order='ascending')
+                or _all_dims_sorted(coord, order='descending')
+            ):
+                warnings.warn(
+                    'The input contains a coordinate with unsorted values '
+                    f'({name}). The results may be unpredictable. '
+                    'Coordinates can be sorted using '
+                    '`scipp.sort(data, dim="to_be_sorted", order="ascending")`.',
+                    RuntimeWarning,
+                    stacklevel=2,
+                )
+        except sc.DTypeError:
+            pass
+
+        if not coord.dims:
+            raise ValueError(
+                "Input data cannot be plotted: it has a scalar coordinate along "
+                f"dimension {name}. Consider dropping this coordinate before plotting. "
+                f"Use ``data.drop_coords('{name}').plot()``."
+            )
+
+
 def preprocess(
     obj: Plottable | list,
     name: str | None = None,
@@ -219,42 +281,19 @@ def preprocess(
     elif coords is not None:
         coords = list(coords)
 
-    out = to_data_array(obj, coords)
+    out = to_data_array(obj)
     check_not_binned(out)
     check_allowed_dtypes(out)
     if name is not None:
-        out.name = name
+        out.name = str(name)
     if not ignore_size:
         _check_size(out)
     if coords is not None:
-        renamed_dims = {}
-        for dim in coords:
-            underlying = out.coords[dim].dims[-1]
-            if underlying in renamed_dims:
-                raise ValueError(
-                    "coords: Cannot use more than one coordinate associated with "
-                    f"the same underlying dimension ({underlying})."
-                )
-            renamed_dims[underlying] = dim
-        out = out.rename_dims(**renamed_dims)
-    for n, coord in out.coords.items():
-        if (coord.ndim == 0) or (n not in out.dims):
-            continue
-        try:
-            if not (
-                _all_dims_sorted(coord, order='ascending')
-                or _all_dims_sorted(coord, order='descending')
-            ):
-                warnings.warn(
-                    'The input contains a coordinate with unsorted values '
-                    f'({n}). The results may be unpredictable. '
-                    'Coordinates can be sorted using '
-                    '`scipp.sort(data, dim="to_be_sorted", order="ascending")`.',
-                    RuntimeWarning,
-                    stacklevel=2,
-                )
-        except sc.DTypeError:
-            pass
+        out = _rename_dims_from_coords(out, coords)
+    out = _add_missing_dimension_coords(out)
+    out = _drop_non_dimension_coords(out)
+    out = _handle_coords_with_left_over_dimensions(out)
+    _check_coord_sanity(out)
     return out
 
 
@@ -277,9 +316,9 @@ def input_to_nodes(obj: PlottableMulti, processor: Callable) -> list[Node]:
     nodes = [Node(processor, inp, name=name) for name, inp in to_nodes]
     for node in nodes:
         if hasattr(processor, 'func'):
-            node.name = processor.func.__name__
+            node.pretty_name = processor.func.__name__
         else:
-            node.name = 'Preprocess data'
+            node.pretty_name = 'Preprocess data'
     return nodes