plopp 25.6.0__py3-none-any.whl → 25.7.0__py3-none-any.whl

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/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/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/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/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
 
 

plopp/plotting/slicer.py

@@ -60,6 +60,7 @@ class Slicer:
         vmin: VariableLike | float = None,
         vmax: VariableLike | float = None,
         cbar: bool = True,
+        enable_player: bool = False,
         **kwargs,
     ):
         nodes = input_to_nodes(
@@ -98,7 +99,9 @@ class Slicer:
         from ..widgets import SliceWidget, slice_dims
 
         self.slider = SliceWidget(
-            nodes[0](), dims=[dim for dim in dims if dim not in keep]
+            nodes[0](),
+            dims=[dim for dim in dims if dim not in keep],
+            enable_player=enable_player,
         )
         self.slider_node = widget_node(self.slider)
         self.slice_nodes = [slice_dims(node, self.slider_node) for node in nodes]
@@ -130,6 +133,7 @@ def slicer(
     vmin: VariableLike | float = None,
     vmax: VariableLike | float = None,
     cbar: bool = True,
+    enable_player: bool = False,
     **kwargs,
 ) -> FigureLike:
     """
@@ -156,6 +160,10 @@ def slicer(
         The maximum value of the y-axis (1d plots) or color range (2d plots).
     cbar:
         Whether to display a colorbar for 2D plots.
+    enable_player:
+        Add a play button to animate the sliders if True. Defaults to False.
+
+        .. versionadded:: 25.07.0
     **kwargs:
         See :py:func:`plopp.plot` for the full list of figure customization arguments.
     """
@@ -167,5 +175,6 @@ def slicer(
         vmax=vmax,
         coords=coords,
         cbar=cbar,
+        enable_player=enable_player,
         **kwargs,
     ).figure

plopp/plotting/xyplot.py

@@ -23,7 +23,17 @@ def _make_data_array(x: sc.Variable, y: sc.Variable) -> sc.DataArray:
     y:
         The variable to use as the data.
     """
-    return sc.DataArray(data=y, coords={x.dim: x})
+    if x.ndim != 1 or y.ndim != 1:
+        raise sc.DimensionError(
+            f'Expected 1 dimension, got {x.ndim} for x and {y.ndim} for y.'
+        )
+    dim = x.dim
+    return sc.DataArray(
+        data=sc.array(dims=[dim], values=y.values, variances=y.variances, unit=y.unit)
+        if y.dim != dim
+        else y,
+        coords={dim: x},
+    )
 
 
 def xyplot(
@@ -48,7 +58,4 @@ def xyplot(
     """
     x = Node(to_variable, x)
     y = Node(to_variable, y)
-    dim = x().dim
-    if dim != y().dim:
-        raise sc.DimensionError("Dimensions of x and y must match")
     return linefigure(Node(_make_data_array, x=x, y=y), **kwargs)

plopp/widgets/drawing.py

@@ -86,12 +86,12 @@ class DrawingTool(ToggleTool):
 
     def make_node(self, artist):
         draw_node = Node(self._get_artist_info(artist=artist, figure=self._figure))
-        draw_node.name = f'Draw node {len(self._draw_nodes)}'
+        draw_node.pretty_name = f'Draw node {len(self._draw_nodes)}'
         nodeid = draw_node.id
         self._draw_nodes[nodeid] = draw_node
         artist.nodeid = nodeid
         output_node = node(self._func)(self._input_node, draw_node)
-        output_node.name = f'Output node {len(self._output_nodes)}'
+        output_node.pretty_name = f'Output node {len(self._output_nodes)}'
         self._output_nodes[nodeid] = output_node
         if self._destination_is_fig:
             output_node.add_view(self._destination.view)

plopp/widgets/linesave.py

@@ -45,7 +45,7 @@ class LineSaveTool(VBar):
 
         data = self._data_node.request_data()
         node = Node(data)
-        node.name = f'Save node {len(self._lines)}'
+        node.pretty_name = f'Save node {len(self._lines)}'
         line_id = node._id
         node.add_view(self._fig.view)
         self._fig.view.render()

plopp/widgets/slice.py

@@ -12,74 +12,121 @@ from ..core.utils import coord_element_to_string
 from .box import VBar
 
 
+class DimSlicer(ipw.VBox):
+    def __init__(
+        self,
+        dim: str,
+        size: int,
+        coord: sc.Variable,
+        slider_constr: type[ipw.Widget],
+        enable_player: bool = False,
+    ):
+        if enable_player and not issubclass(slider_constr, ipw.IntSlider):
+            raise TypeError(
+                "Player can only be enabled for IntSlider, not for IntRangeSlider."
+            )
+        widget_args = {
+            'step': 1,
+            'description': dim,
+            'min': 0,
+            'max': size - 1,
+            'value': (size - 1) // 2 if slider_constr is ipw.IntSlider else None,
+            'continuous_update': True,
+            'readout': False,
+            'layout': {"width": "200px", "margin": "0px 0px 0px 10px"},
+            'style': {'description_width': 'initial'},
+        }
+        self.slider = slider_constr(**widget_args)
+        self.continuous_update = ipw.Checkbox(
+            value=True,
+            tooltip="Continuous update",
+            indent=False,
+            layout={"width": "20px"},
+        )
+        self.label = ipw.Label(
+            value=coord_element_to_string(coord[dim, self.slider.value])
+        )
+        ipw.jslink(
+            (self.continuous_update, 'value'), (self.slider, 'continuous_update')
+        )
+
+        children = [self.slider, self.continuous_update, self.label]
+        if enable_player:
+            self.player = ipw.Play(
+                value=self.slider.value,
+                min=self.slider.min,
+                max=self.slider.max,
+                step=self.slider.step,
+                interval=100,
+                description='Play',
+            )
+            ipw.jslink((self.player, 'value'), (self.slider, 'value'))
+            children.insert(0, self.player)
+
+        self.dim = dim
+        self.coord = coord
+        self.slider.observe(self._update_label, names='value')
+
+        super().__init__([ipw.HBox(children)])
+
+    def _update_label(self, change: dict[str, Any]):
+        """
+        Update the readout label with the coordinate value, instead of the integer
+        readout index.
+        """
+        self.label.value = coord_element_to_string(self.coord[self.dim, change['new']])
+
+    @property
+    def value(self) -> int | tuple[int, int]:
+        """
+        The value of the slider.
+        """
+        return self.slider.value
+
+    @value.setter
+    def value(self, value: int | tuple[int, int]):
+        self.slider.value = value
+
+
 class _BaseSliceWidget(VBar, ipw.ValueWidget):
-    def __init__(self, da: sc.DataArray, dims: list[str], slider_constr: ipw.Widget):
+    def __init__(
+        self,
+        da: sc.DataArray,
+        dims: list[str],
+        slider_constr: ipw.Widget,
+        enable_player: bool = False,
+    ):
         if isinstance(dims, str):
             dims = [dims]
-        self._slider_dims = dims
         self.controls = {}
         self.view = None
         children = []
 
-        for dim in self._slider_dims:
+        for dim in dims:
             coord = (
                 da.coords[dim]
                 if dim in da.coords
                 else sc.arange(dim, da.sizes[dim], unit=None)
             )
-            widget_args = {
-                'step': 1,
-                'description': dim,
-                'min': 0,
-                'max': da.sizes[dim] - 1,
-                'value': (da.sizes[dim] - 1) // 2
-                if slider_constr is ipw.IntSlider
-                else None,
-                'continuous_update': True,
-                'readout': False,
-                'layout': {"width": "200px"},
-                'style': {'description_width': 'initial'},
-            }
-            slider = slider_constr(**widget_args)
-            continuous_update = ipw.Checkbox(
-                value=True,
-                tooltip="Continuous update",
-                indent=False,
-                layout={"width": "20px"},
+            self.controls[dim] = DimSlicer(
+                dim=dim,
+                size=da.sizes[dim],
+                coord=coord,
+                slider_constr=slider_constr,
+                enable_player=enable_player,
             )
-            label = ipw.Label(value=coord_element_to_string(coord[dim, slider.value]))
-            ipw.jslink((continuous_update, 'value'), (slider, 'continuous_update'))
-
-            self.controls[dim] = {
-                'continuous': continuous_update,
-                'slider': slider,
-                'label': label,
-                'coord': coord,
-            }
-            slider.observe(self._update_label, names='value')
-            slider.observe(self._on_subwidget_change, names='value')
-            children.append(ipw.HBox([continuous_update, slider, label]))
+            self.controls[dim].slider.observe(self._on_subwidget_change, names='value')
+            children.append(self.controls[dim])
 
         self._on_subwidget_change()
         super().__init__(children)
 
-    def _update_label(self, change: dict[str, Any]):
-        """
-        Update the readout label with the coordinate value, instead of the integer
-        readout index.
-        """
-        dim = change['owner'].description
-        coord = self.controls[dim]['coord'][dim, change['new']]
-        self.controls[dim]['label'].value = coord_element_to_string(coord)
-
     def _on_subwidget_change(self, _=None):
         """
         Update the value of the widget.
         The value is a dict containing one entry per slider, giving the slider's value.
         """
-        self.value = {
-            dim: self.controls[dim]['slider'].value for dim in self._slider_dims
-        }
+        self.value = {dim: slicer.slider.value for dim, slicer in self.controls.items()}
 
 
 SliceWidget = partial(_BaseSliceWidget, slider_constr=ipw.IntSlider)
@@ -95,6 +142,10 @@ da:
     The input data array.
 dims:
     The dimensions to make sliders for.
+enable_player:
+    Add a play button to animate the slider if True. Defaults to False.
+
+    .. versionadded:: 25.07.0
 """
 
 RangeSliceWidget = partial(_BaseSliceWidget, slider_constr=ipw.IntRangeSlider)

{plopp-25.6.0.dist-info → plopp-25.7.0.dist-info}/METADATA

@@ -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.dist-info → plopp-25.7.0.dist-info}/RECORD

@@ -25,10 +25,10 @@ plopp/backends/pythreejs/outline.py,sha256=WUqtUj8GMAUzUqOocFjdT8F7WBeV9jgMSYmXD
 plopp/backends/pythreejs/scatter3d.py,sha256=Z8D0l3hBJ2qlC4BIAAoHCAa97uf6IViFNt23f9wzFFI,7049
 plopp/core/__init__.py,sha256=s25RIbKplHSRn0jjtLADPQl72JLf_KLRMRCfeMDI_UA,205
 plopp/core/__init__.pyi,sha256=FU5U5nymhzbgBRolZSh1tqYDJ3M2djUv71mriWHD1hI,294
-plopp/core/graph.py,sha256=beHDxqF4C-6wd18TkYue3KqYutEYJ2EwoEBbWIqWQNs,3841
-plopp/core/helpers.py,sha256=Dua9KWOk2cCpDyWPUrak6kymUx7QvjRI2LNJRoGDMcY,1193
+plopp/core/graph.py,sha256=dTJa1QIQDEuDUYZIwF7NT444wkuXxb0wwBrx311vTT8,3855
+plopp/core/helpers.py,sha256=BVunzkcYOXoYjawutFtKP8WbWN1h1OlRrSd_i9TY090,1200
 plopp/core/limits.py,sha256=ojb3MTxlWNz2ibHXu9P-agzYV8HxPCGSB2D0oxoO9RQ,3572
-plopp/core/node_class.py,sha256=5SnVELRZSzcTD1ku8hDkWygCWsDMpedvcyYGZV-CHlw,7462
+plopp/core/node_class.py,sha256=Vzjf0f7UTiCVZC8m_dwh2gGPwnJqD0HOR8HuUX5TsDI,7483
 plopp/core/typing.py,sha256=JL_mMdFq2dNu6LuZYSBfOXGZSEn0VIJK_lr-LbC11t4,2903
 plopp/core/utils.py,sha256=qxdOLRODgv3b0dDywT0JomsVrgifS_siC-ZpzJqgblo,7120
 plopp/core/view.py,sha256=9WulgLHg8aPjePz967WLWieTM40dvqlgJitu-AS3WdM,1972
@@ -43,33 +43,33 @@ plopp/graphics/bbox.py,sha256=3WeMgu5LgWIXLJTYVT7_USwaAcS7cQPNCk6B0gvuNGo,3596
 plopp/graphics/camera.py,sha256=fXc1YH7Tp-rwKkcYeE-mHrxMz3SKauj5xJCRuKv-QPs,5323
 plopp/graphics/colormapper.py,sha256=u5cADKU9lrRkJ_a969i_5z-mdT0-lBnEonc0PW_xSXA,9643
 plopp/graphics/figures.py,sha256=PLWQLnQNWz8epubYlK7HLSkvPGJmTAmHjJM2DqpvLe8,2735
-plopp/graphics/graphicalview.py,sha256=u5sz3CebhVLoEeKPpzlBlPfRrRORxDmruyfhLXDbH00,9436
+plopp/graphics/graphicalview.py,sha256=07xpJVnvuNlaWGsJshg_wL81jG57JhRxI23E7_WYI2M,9435
 plopp/graphics/tiled.py,sha256=gXYZVAs6wRFKezzN3VlEvm7_z2zx3IDYfGZQZqrpL80,1386
 plopp/plotting/__init__.py,sha256=s25RIbKplHSRn0jjtLADPQl72JLf_KLRMRCfeMDI_UA,205
 plopp/plotting/__init__.pyi,sha256=95wYGfM5PT0Y0Ov_ue7rBrHvHxrtex-2WEYtfFzBvE0,475
-plopp/plotting/common.py,sha256=7xR2aWUWzKyxshlPn8B-OWQ5Hy8wiMn-qtPywkLsNRs,9515
+plopp/plotting/common.py,sha256=dwtOpmMNY8deLWskiByKXficZUqX1pPGrkT_ieDN36c,10984
 plopp/plotting/inspector.py,sha256=fT4v342pqTzihKaweoGD4WaQ5eDdyngK7W451Mh2Ffw,3586
 plopp/plotting/mesh3d.py,sha256=KjAtlVlLYslwgP_uE067WtJRgNURkhaz0PPUuYLlJyw,2778
 plopp/plotting/plot.py,sha256=WQzw1vHGljWY1tQU1InQWe2-M-vCW2IRiL-v7cnw46w,3886
 plopp/plotting/scatter.py,sha256=ybPWFHFwxt_Bzv3Dy-yAFCRHW5HQEggcNihpzWduH7A,3161
 plopp/plotting/scatter3d.py,sha256=oizd-BCgmvNu_fSV6FQt9oe7lPn4h2Zc1ohKmor-d78,3819
-plopp/plotting/slicer.py,sha256=A3g26czD6GM3vBlVS-IBOnCOlpaERqUhjT-_POYJEHQ,5877
+plopp/plotting/slicer.py,sha256=ym20mXJtp_msGOet18wr0mb4TL0z4ti6W9uFo_5cvKc,6169
 plopp/plotting/superplot.py,sha256=0EnzgSmNrdPHXooqj6GNR0IAApEHyfjgxYIPgPVO_5o,1416
-plopp/plotting/xyplot.py,sha256=t_0GC2TlC6QZPKN4tfgLRUUBDhJ5zoNJjsRyYxLX_xI,1448
+plopp/plotting/xyplot.py,sha256=zi-RcsgonnR747aH3zp75at4ntgZ0t0rSdKEeVlReMI,1641
 plopp/widgets/__init__.py,sha256=s25RIbKplHSRn0jjtLADPQl72JLf_KLRMRCfeMDI_UA,205
 plopp/widgets/__init__.pyi,sha256=4hVX7I3VEjE3oy2AGVvguYsIgg7cVrhKGpX7xVgGe9Y,844
 plopp/widgets/box.py,sha256=v5Gd3sY0WXcc3UfkcXxZboPG02sfOMXIo50tmpxPwVs,1806
 plopp/widgets/checkboxes.py,sha256=52yJryEu1upYafFxqoTOdAZmHeKzCI_CJiCWSezCtRA,2430
 plopp/widgets/clip3d.py,sha256=L90HUd3bjEU3BaPdK8DnUbeeFNqfFyBWDEwaG9nP-M8,14602
 plopp/widgets/debounce.py,sha256=V5aIcnb465oqXZX-UG_DR7GjvoG6D_C2jjEUBmguGDA,1292
-plopp/widgets/drawing.py,sha256=3aWEYUXsNNBJFey-7cPXbQ4bLQpDbIJe-kSNB2yonbE,6238
-plopp/widgets/linesave.py,sha256=FAM1toc71fg3SfRrU-r_KXjHKBOJU4qKXs5bebReNiU,2451
-plopp/widgets/slice.py,sha256=ihiGEGGva_2WZIug-kizg1I5SFdMzu4_8DDzuHWIKeA,4212
+plopp/widgets/drawing.py,sha256=Pcozffq7I5H9x57GNBJVvkCjVR6eaPBuxyHlFkEEjzQ,6252
+plopp/widgets/linesave.py,sha256=s5QcY-31x7Hvf9iLHmzfFIzodXTD9BX0Av3NlG8GS88,2458
+plopp/widgets/slice.py,sha256=hG1QzLsjmxjY4fjQwtlu8GxK6zzalrZsZxZzhwIaskg,5499
 plopp/widgets/style.py,sha256=Fw4S8te0xDyT8-kWu4Ut35aLgyr98qMlWZRbXbd1-dk,184
 plopp/widgets/toolbar.py,sha256=ueNeOZSC2suAG7nCJzqwl8DmtWD5c2J8VkuP-XzJRwI,4683
 plopp/widgets/tools.py,sha256=9l7LmB8qG0OTt5ZJihJzqRna1ouxJthO_Ahnq7WKTtY,7172
-plopp-25.6.0.dist-info/licenses/LICENSE,sha256=fCqnkzCwkGneGtgOidkO2b3ed6SGZT0yhuworuJG0K0,1553
-plopp-25.6.0.dist-info/METADATA,sha256=pXa9A1kJV4J_ESLKfWthwIvFzQc0sXhArjZPiBkbq3A,4533
-plopp-25.6.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-plopp-25.6.0.dist-info/top_level.txt,sha256=Lk_GLFh37eX-3PO3c6bPkDpir7GjJmbQHYza3IpIphc,6
-plopp-25.6.0.dist-info/RECORD,,
+plopp-25.7.0.dist-info/licenses/LICENSE,sha256=fCqnkzCwkGneGtgOidkO2b3ed6SGZT0yhuworuJG0K0,1553
+plopp-25.7.0.dist-info/METADATA,sha256=ORDD8s280azbvWqw84HVSpZ9uZ1HoGB8L13Uf7LTyVg,4545
+plopp-25.7.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+plopp-25.7.0.dist-info/top_level.txt,sha256=Lk_GLFh37eX-3PO3c6bPkDpir7GjJmbQHYza3IpIphc,6
+plopp-25.7.0.dist-info/RECORD,,