plopp 25.6.0__tar.gz → 25.6.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plopp
-Version: 25.6.0
+Version: 25.6.1
 Summary: Visualization library for Scipp
 Author: Scipp contributors
 License: BSD 3-Clause License

{plopp-25.6.0 → plopp-25.6.1}/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.6.1}/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,7 +281,7 @@ 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:
@@ -227,34 +289,11 @@ def preprocess(
     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
 
 

{plopp-25.6.0 → plopp-25.6.1}/src/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-25.6.0 → plopp-25.6.1}/src/plopp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plopp
-Version: 25.6.0
+Version: 25.6.1
 Summary: Visualization library for Scipp
 Author: Scipp contributors
 License: BSD 3-Clause License

{plopp-25.6.0 → plopp-25.6.1}/tests/plotting/plot_2d_test.py

@@ -99,14 +99,46 @@ def test_use_non_dimension_coords(linspace):
     assert p.canvas.ymax == 3.3 * da.coords['yy'].max().value
 
 
-def test_use_two_coords_for_same_underlying_dimension_raises():
-    da = data_array(ndim=2)
+@pytest.mark.parametrize('linspace', [True, False])
+def test_single_use_non_dimension_coords(linspace):
+    da = data_array(ndim=2, linspace=linspace)
+    da.coords['xx2'] = da.coords['xx'] ** 2
+    da.coords['yy2'] = da.coords['yy'] ** 2
+    p = pp.plot(da, coords=['xx2'])
+    assert p.canvas.dims['x'] == 'xx2'
+    assert p.canvas.dims['y'] == 'yy'
+
+
+@pytest.mark.parametrize('linspace', [True, False])
+def test_use_two_coords_for_same_underlying_dimension_raises(linspace):
+    da = data_array(ndim=2, linspace=linspace)
     da.coords['a'] = da.coords['xx'] * 2
+    da.coords['b'] = da.coords['xx'] * 2.5
     msg = "coords: Cannot use more than one coordinate"
     with pytest.raises(ValueError, match=msg):
-        pp.plot(da, coords=['xx', 'a'])
+        pp.plot(da, coords=['a', 'b'])
+    with pytest.raises(ValueError, match=msg):
+        pp.plot(da, coords=['b', 'a'])
+
+
+@pytest.mark.parametrize('linspace', [True, False])
+def test_use_dimension_coord_in_coords_arg(linspace):
+    da = data_array(ndim=2, linspace=linspace)
+    p = pp.plot(da, coords=['xx'])
+    assert p.canvas.dims['x'] == 'xx'
+
+
+@pytest.mark.parametrize('linspace', [True, False])
+def test_use_dimension_coord_and_other_coord_for_same_underlying_dimension_raises(
+    linspace,
+):
+    da = data_array(ndim=2, linspace=linspace)
+    da.coords['a'] = da.coords['xx'] * 2
+    msg = "coords: Cannot use more than one coordinate"
     with pytest.raises(ValueError, match=msg):
         pp.plot(da, coords=['a', 'xx'])
+    with pytest.raises(ValueError, match=msg):
+        pp.plot(da, coords=['xx', 'a'])
 
 
 @pytest.mark.parametrize('ext', ['jpg', 'png', 'pdf', 'svg'])

{plopp-25.6.0 → plopp-25.6.1}/tests/plotting/xyplot_test.py

@@ -18,6 +18,15 @@ def test_xyplot_variable():
     assert fig.canvas.ylabel == '[K]'
 
 
+def test_xyplot_woth_variances():
+    x = sc.arange('time', 20.0, unit='s')
+    y = sc.arange('time', 100.0, 120.0, unit='K')
+    y.variances = y.values
+    fig = pp.xyplot(x, y)
+    [line] = fig.artists.values()
+    assert line._error is not None
+
+
 def test_xyplot_ndarray():
     N = 50
     x = np.arange(float(N))
@@ -31,11 +40,10 @@ def test_xyplot_list():
     pp.xyplot(x, y)
 
 
-def test_xyplot_different_dims_raises():
+def test_xyplot_different_dims():
     x = sc.arange('x', 20.0, unit='s')
     y = sc.arange('y', 100.0, 120.0, unit='K')
-    with pytest.raises(sc.DimensionError, match='Dimensions of x and y must match'):
-        pp.xyplot(x, y)
+    pp.xyplot(x, y)
 
 
 def test_xyplot_data_array_raises():
@@ -50,9 +58,9 @@ def test_xyplot_data_array_raises():
 def test_xyplot_2d_variable_raises():
     x = sc.arange('x', 50.0, unit='s')
     y = pp.data.data2d().data
-    with pytest.raises(sc.DimensionError, match='Expected 1 dimensions, got 2'):
+    with pytest.raises(sc.DimensionError, match='Expected 1 dimension'):
         pp.xyplot(x, y)
-    with pytest.raises(sc.DimensionError, match='Expected 1 dimensions, got 2'):
+    with pytest.raises(sc.DimensionError, match='Expected 1 dimension'):
         pp.xyplot(y, x)