legend-pydataobj 1.8.1__tar.gz → 1.9.0__tar.gz

{legend_pydataobj-1.8.1 → legend_pydataobj-1.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: legend_pydataobj
-Version: 1.8.1
+Version: 1.9.0
 Summary: LEGEND Python Data Objects
 Author: The LEGEND Collaboration
 Maintainer: The LEGEND Collaboration
@@ -702,6 +702,7 @@ Requires-Dist: awkward-pandas
 Requires-Dist: colorlog
 Requires-Dist: h5py>=3.2
 Requires-Dist: hdf5plugin
+Requires-Dist: hist
 Requires-Dist: numba!=0.53.*,!=0.54.*
 Requires-Dist: numexpr
 Requires-Dist: numpy>=1.21

{legend_pydataobj-1.8.1 → legend_pydataobj-1.9.0}/pyproject.toml

@@ -36,6 +36,7 @@ dependencies = [
     "colorlog",
     "h5py>=3.2",
     "hdf5plugin",
+    "hist",
     "numba!=0.53.*,!=0.54.*",
     "numexpr",
     "numpy>=1.21",

{legend_pydataobj-1.8.1 → legend_pydataobj-1.9.0}/src/legend_pydataobj.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: legend_pydataobj
-Version: 1.8.1
+Version: 1.9.0
 Summary: LEGEND Python Data Objects
 Author: The LEGEND Collaboration
 Maintainer: The LEGEND Collaboration
@@ -702,6 +702,7 @@ Requires-Dist: awkward-pandas
 Requires-Dist: colorlog
 Requires-Dist: h5py>=3.2
 Requires-Dist: hdf5plugin
+Requires-Dist: hist
 Requires-Dist: numba!=0.53.*,!=0.54.*
 Requires-Dist: numexpr
 Requires-Dist: numpy>=1.21

{legend_pydataobj-1.8.1 → legend_pydataobj-1.9.0}/src/legend_pydataobj.egg-info/SOURCES.txt

@@ -49,6 +49,7 @@ src/lgdo/types/array.py
 src/lgdo/types/arrayofequalsizedarrays.py
 src/lgdo/types/encoded.py
 src/lgdo/types/fixedsizearray.py
+src/lgdo/types/histogram.py
 src/lgdo/types/lgdo.py
 src/lgdo/types/scalar.py
 src/lgdo/types/struct.py
@@ -78,6 +79,7 @@ tests/types/test_array.py
 tests/types/test_arrayofequalsizedarrays.py
 tests/types/test_encoded.py
 tests/types/test_fixedsizearray.py
+tests/types/test_histogram.py
 tests/types/test_representations.py
 tests/types/test_scalar.py
 tests/types/test_struct.py

{legend_pydataobj-1.8.1 → legend_pydataobj-1.9.0}/src/legend_pydataobj.egg-info/requires.txt

@@ -3,6 +3,7 @@ awkward-pandas
 colorlog
 h5py>=3.2
 hdf5plugin
+hist
 numba!=0.53.*,!=0.54.*
 numexpr
 numpy>=1.21

{legend_pydataobj-1.8.1 → legend_pydataobj-1.9.0}/src/lgdo/__init__.py

@@ -33,6 +33,8 @@ basic data object classes are:
   :class:`dict`
 * :class:`.Table`: a :class:`.Struct` whose elements ("columns") are all array
   types with the same length (number of rows)
+* :class:`.Histogram`: holds an array of histogrammed data, and the associated
+  binning of arbitrary dimensionality.
 
 Currently the primary on-disk format for LGDO object is LEGEND HDF5 (LH5) files. IO
 is done via the class :class:`.lh5_store.LH5Store`. LH5 files can also be
@@ -50,6 +52,7 @@ from .types import (
     ArrayOfEncodedEqualSizedArrays,
     ArrayOfEqualSizedArrays,
     FixedSizeArray,
+    Histogram,
     Scalar,
     Struct,
     Table,
@@ -63,6 +66,7 @@ __all__ = [
     "ArrayOfEqualSizedArrays",
     "ArrayOfEncodedEqualSizedArrays",
     "FixedSizeArray",
+    "Histogram",
     "LGDO",
     "Scalar",
     "Struct",

{legend_pydataobj-1.8.1 → legend_pydataobj-1.9.0}/src/lgdo/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.8.1'
-__version_tuple__ = version_tuple = (1, 8, 1)
+__version__ = version = '1.9.0'
+__version_tuple__ = version_tuple = (1, 9, 0)

{legend_pydataobj-1.8.1 → legend_pydataobj-1.9.0}/src/lgdo/lh5/_serializers/__init__.py

@@ -7,6 +7,7 @@ from .read.array import (
     _h5_read_ndarray,
 )
 from .read.composite import (
+    _h5_read_histogram,
     _h5_read_lgdo,
     _h5_read_struct,
     _h5_read_table,
@@ -32,6 +33,7 @@ __all__ = [
     "_h5_read_array_of_equalsized_arrays",
     "_h5_read_struct",
     "_h5_read_table",
+    "_h5_read_histogram",
     "_h5_read_scalar",
     "_h5_read_array_of_encoded_equalsized_arrays",
     "_h5_read_vector_of_encoded_vectors",

{legend_pydataobj-1.8.1 → legend_pydataobj-1.9.0}/src/lgdo/lh5/_serializers/read/composite.py

@@ -13,6 +13,7 @@ from ....types import (
     ArrayOfEncodedEqualSizedArrays,
     ArrayOfEqualSizedArrays,
     FixedSizeArray,
+    Histogram,
     Scalar,
     Struct,
     Table,
@@ -168,6 +169,19 @@ def _h5_read_lgdo(
             decompress=decompress,
         )
 
+    if lgdotype is Histogram:
+        return _h5_read_histogram(
+            h5o,
+            start_row=start_row,
+            n_rows=n_rows,
+            idx=idx,
+            use_h5idx=use_h5idx,
+            field_mask=field_mask,
+            obj_buf=obj_buf,
+            obj_buf_start=obj_buf_start,
+            decompress=decompress,
+        )
+
     if lgdotype is ArrayOfEncodedEqualSizedArrays:
         return _h5_read_array_of_encoded_equalsized_arrays(
             h5o,
@@ -385,3 +399,51 @@ def _h5_read_table(
     utils.check_obj_buf_attrs(obj_buf.attrs, attrs, h5g)
 
     return obj_buf, n_rows_read
+
+
+def _h5_read_histogram(
+    h5g,
+    start_row=0,
+    n_rows=sys.maxsize,
+    idx=None,
+    use_h5idx=False,
+    field_mask=None,
+    obj_buf=None,
+    obj_buf_start=0,
+    decompress=True,
+):
+    if obj_buf is not None or obj_buf_start != 0:
+        msg = "reading a histogram into an existing object buffer is not supported"
+        raise LH5DecodeError(msg, h5g)
+
+    struct, n_rows_read = _h5_read_struct(
+        h5g,
+        start_row,
+        n_rows,
+        idx,
+        use_h5idx,
+        field_mask,
+        decompress,
+    )
+    binning = []
+    for _, a in struct.binning.items():
+        be = a.binedges
+        if isinstance(be, Struct):
+            b = (None, be.first.value, be.last.value, be.step.value, a.closedleft.value)
+        elif isinstance(be, Array):
+            b = (be, None, None, None, a.closedleft.value)
+        else:
+            msg = "unexpected binning of histogram"
+            raise LH5DecodeError(msg, h5g)
+        ax = Histogram.Axis(*b)
+        # copy attrs to "clone" the "whole" struct.
+        ax.attrs = a.getattrs(datatype=True)
+        ax["binedges"].attrs = be.getattrs(datatype=True)
+        binning.append(ax)
+
+    isdensity = struct.isdensity.value
+    weights = struct.weights
+    attrs = struct.getattrs(datatype=True)
+    histogram = Histogram(weights, binning, isdensity, attrs=attrs)
+
+    return histogram, n_rows_read

{legend_pydataobj-1.8.1 → legend_pydataobj-1.9.0}/src/lgdo/lh5/_serializers/write/composite.py

@@ -63,8 +63,15 @@ def _h5_write_lgdo(
         msg = f"can't overwrite '{name}' in wo_mode 'write_safe'"
         raise LH5EncodeError(msg, lh5_file, group, name)
 
-    # struct or table or waveform table
+    # struct, table, waveform table or histogram.
     if isinstance(obj, types.Struct):
+        if isinstance(obj, types.Histogram) and wo_mode not in ["w", "o", "of"]:
+            msg = f"can't append-write histogram in wo_mode '{wo_mode}'"
+            raise LH5EncodeError(msg, lh5_file, group, name)
+        if isinstance(obj, types.Histogram) and write_start != 0:
+            msg = f"can't write histogram in wo_mode '{wo_mode}' with write_start != 0"
+            raise LH5EncodeError(msg, lh5_file, group, name)
+
         return _h5_write_struct(
             obj,
             name,

{legend_pydataobj-1.8.1 → legend_pydataobj-1.9.0}/src/lgdo/lh5/datatype.py

@@ -14,6 +14,7 @@ _lgdo_datatype_map: dict[str, lgdo.LGDO] = OrderedDict(
             lgdo.ArrayOfEncodedEqualSizedArrays,
             r"^array_of_encoded_equalsized_arrays<1,1>\{.+\}$",
         ),
+        (lgdo.Histogram, r"^struct\{binning,weights,isdensity\}$"),
         (lgdo.Struct, r"^struct\{.*\}$"),
         (lgdo.Table, r"^table\{.*\}$"),
         (lgdo.FixedSizeArray, r"^fixedsize_array<\d+>\{.+\}$"),

{legend_pydataobj-1.8.1 → legend_pydataobj-1.9.0}/src/lgdo/lh5_store.py

@@ -20,6 +20,7 @@ from .types import (
     ArrayOfEncodedEqualSizedArrays,  # noqa: F401
     ArrayOfEqualSizedArrays,  # noqa: F401
     FixedSizeArray,  # noqa: F401
+    Histogram,  # noqa: F401
     Scalar,
     Struct,
     Table,  # noqa: F401

{legend_pydataobj-1.8.1 → legend_pydataobj-1.9.0}/src/lgdo/types/__init__.py

@@ -6,6 +6,7 @@ from .array import Array
 from .arrayofequalsizedarrays import ArrayOfEqualSizedArrays
 from .encoded import ArrayOfEncodedEqualSizedArrays, VectorOfEncodedVectors
 from .fixedsizearray import FixedSizeArray
+from .histogram import Histogram
 from .lgdo import LGDO
 from .scalar import Scalar
 from .struct import Struct
@@ -18,6 +19,7 @@ __all__ = [
     "ArrayOfEqualSizedArrays",
     "ArrayOfEncodedEqualSizedArrays",
     "FixedSizeArray",
+    "Histogram",
     "LGDO",
     "Scalar",
     "Struct",

legend_pydataobj-1.9.0/src/lgdo/types/histogram.py

@@ -0,0 +1,404 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import Any
+
+import hist
+import numpy as np
+from numpy.typing import NDArray
+
+from .array import Array
+from .lgdo import LGDO
+from .scalar import Scalar
+from .struct import Struct
+
+
+class Histogram(Struct):
+    class Axis(Struct):
+        def __init__(
+            self,
+            edges: NDArray | Array | None,
+            first: float | None,
+            last: float | None,
+            step: float | None,
+            closedleft: bool = True,
+            binedge_attrs: dict[str, Any] | None = None,
+        ) -> None:
+            """
+            A special struct to group axis parameters for use in a :class:`Histogram`.
+
+            Depending on the parameters, an axis either can have
+
+            * a binning described by a range object, if ``first``, ``last`` and ``step``
+              are passed, or
+            * a variable binning described by the ``edges`` array.
+
+            Parameters
+            ----------
+            edges
+                an array of edges that describe the binning of this axis.
+            first
+                left edge of the leftmost bin
+            last
+                right edge of the rightmost bin
+            step
+                step size (width of each bin)
+            closedleft
+                if True, the bin intervals are left-closed :math:`[a,b)`;
+                if False, intervals are right-closed :math:`(a,b]`.
+            binedge_attrs
+                attributes that will be added to the ``binedges`` LGDO that
+                is part of the axis struct.
+            """
+            if edges is not None and (
+                first is not None or last is not None or step is not None
+            ):
+                msg = "can only construct Axis either from edges or from range"
+                raise ValueError(msg)
+            if edges is None and (first is None or last is None or step is None):
+                msg = "did not pass all range parameters"
+                raise ValueError(msg)
+
+            if edges is None:
+                edges = Struct(
+                    {
+                        "first": Scalar(first),
+                        "last": Scalar(last),
+                        "step": Scalar(step),
+                    },
+                    binedge_attrs,
+                )
+            else:
+                if not isinstance(edges, Array):
+                    edges = Array(edges, attrs=binedge_attrs)
+                elif binedge_attrs is not None:
+                    msg = "passed both binedge as Array LGDO instance and binedge_attrs"
+                    raise ValueError(msg)
+
+                if len(edges.nda.shape) != 1:
+                    msg = "must pass an array<1>{real} as edges vector"
+                    raise ValueError(msg)
+
+            super().__init__({"binedges": edges, "closedleft": Scalar(closedleft)})
+
+        @classmethod
+        def from_edges(
+            cls,
+            edges: NDArray | Iterable[float],
+            binedge_attrs: dict[str, Any] | None = None,
+        ) -> Histogram.Axis:
+            """Create a new axis with variable binning described by ``edges``."""
+            edges = np.array(edges)
+            return cls(edges, None, None, None, True, binedge_attrs)
+
+        @classmethod
+        def from_range_edges(
+            cls,
+            edges: NDArray | Iterable[float],
+            binedge_attrs: dict[str, Any] | None = None,
+        ) -> Histogram.Axis:
+            """Create a new axis from the binning described by ``edges``, but try to convert it to
+            a evenly-spaced range object first.
+
+            .. warning ::
+
+                This function might return a wrong binning, especially in the case of very small
+                magnitudes of the spacing. See the documentation of :func:`numpy.isclose` for
+                details. Use this function only with caution, if you know the binning's order of
+                magniutude.
+            """
+            edges = np.array(edges)
+            edge_diff = np.diff(edges)
+            if np.any(~np.isclose(edge_diff, edge_diff[0])):
+                return cls(edges, None, None, None, True, binedge_attrs)
+            return cls(None, edges[0], edges[-1], edge_diff[0], True, binedge_attrs)
+
+        @property
+        def is_range(self) -> bool:
+            return isinstance(self["binedges"], Struct)
+
+        @property
+        def first(self) -> float:
+            if not self.is_range:
+                msg = "Axis is not a range"
+                raise TypeError(msg)
+            return self["binedges"]["first"].value
+
+        @property
+        def last(self) -> float:
+            if not self.is_range:
+                msg = "Axis is not a range"
+                raise TypeError(msg)
+            return self["binedges"]["last"].value
+
+        @property
+        def step(self) -> float:
+            if not self.is_range:
+                msg = "Axis is not a range"
+                raise TypeError(msg)
+            return self["binedges"]["step"].value
+
+        @property
+        def closedleft(self) -> bool:
+            return self["closedleft"].value
+
+        @property
+        def nbins(self) -> int:
+            """Return the number of bins, both for variable and range binning."""
+            if self.is_range:
+                bins = (self.last - self.first) / self.step
+                bins_int = int(np.rint(bins))
+                assert np.isclose(bins, bins_int)
+                return bins_int
+            return len(self["binedges"].nda) - 1
+
+        @property
+        def edges(self) -> NDArray:
+            """Return all binedges, both for variable and range binning."""
+            if self.is_range:
+                return np.linspace(self.first, self.last, self.nbins + 1)
+            return self["binedges"].nda
+
+        def __str__(self) -> str:
+            thr_orig = np.get_printoptions()["threshold"]
+            np.set_printoptions(threshold=8)
+
+            if self.is_range:
+                string = f"first={self.first}, last={self.last}, step={self.step}"
+            else:
+                string = f"edges={self.edges}"
+            string += f", closedleft={self.closedleft}"
+
+            attrs = self.get_binedgeattrs()
+            if attrs:
+                string += f" with attrs={attrs}"
+
+            np.set_printoptions(threshold=thr_orig)
+            return string
+
+        def get_binedgeattrs(self, datatype: bool = False) -> dict:
+            """Return a copy of the LGDO attributes dictionary of the binedges
+
+            Parameters
+            ----------
+            datatype
+                if ``False``, remove ``datatype`` attribute from the output
+                dictionary.
+            """
+            return self["binedges"].getattrs(datatype)
+
+    def __init__(
+        self,
+        weights: hist.Hist | NDArray | Array,
+        binning: None
+        | Iterable[Histogram.Axis]
+        | Iterable[NDArray]
+        | Iterable[tuple[float, float, float]] = None,
+        isdensity: bool = False,
+        attrs: dict[str, Any] | None = None,
+        binedge_attrs: dict[str, Any] | None = None,
+    ) -> None:
+        """A special struct to contain histogrammed data.
+
+        Parameters
+        ----------
+        weights
+            An :class:`numpy.ndarray` to be used for this object's internal
+            array, or a :class:`hist.Hist` object, whose data view is used
+            for this object's internal array.
+            Note: the array/histogram view is used directly, not copied
+        binning
+            * has to by None if a :class:`hist.Hist` has been passed as ``weights``
+            * can be a list of pre-initialized :class:`Histogram.Axis`
+            * can be a list of tuples, each representing a range, ``(first, last, step)``
+            * can be a list of numpy arrays, as returned by :func:`numpy.histogramdd`.
+        isdensity
+            If True, all bin contents represent a density (amount per volume), and not
+            an absolute amount.
+        binedge_attrs
+            attributes that will be added to the all ``binedges`` of all axes.
+            This does not work if :class:`Histogram.Axis` instances are directly passed
+            as binning.
+        attrs
+            a set of user attributes to be carried along with this LGDO.
+        """
+        if isinstance(weights, hist.Hist):
+            if binning is not None:
+                msg = "not allowed to pass custom binning if constructing from hist.Hist instance"
+                raise ValueError(msg)
+            if isdensity:
+                msg = "not allowed to pass isdensity=True if constructing from hist.Hist instance"
+                raise ValueError(msg)
+
+            if weights.sum(flow=True) != weights.sum(flow=False):
+                msg = "flow bins of hist.Hist cannot be represented"
+                raise ValueError(msg)
+            weights_view = weights.view(flow=False)
+            if type(weights_view) is not np.ndarray:
+                msg = "only simple numpy-backed storages can be used in a hist.Hist"
+                raise ValueError(msg)
+            w = Array(weights_view)
+
+            b = []
+            for ax in weights.axes:
+                if not isinstance(ax, (hist.axis.Regular, hist.axis.Variable)):
+                    msg = "only regular or variable axes of hist.Hist can be converted"
+                    raise ValueError(msg)
+                if isinstance(ax, hist.axis.Regular):
+                    step = (ax.edges[-1] - ax.edges[0]) / ax.size
+                    bax = Histogram.Axis(
+                        None, ax.edges[0], ax.edges[-1], step, True, binedge_attrs
+                    )
+                    b.append(bax)
+                else:
+                    b.append(Histogram.Axis.from_edges(ax.edges, binedge_attrs))
+        else:
+            if binning is None:
+                msg = "need to also pass binning if passing histogram as array"
+                raise ValueError(msg)
+            w = weights if isinstance(weights, Array) else Array(weights)
+
+            if all(isinstance(ax, Histogram.Axis) for ax in binning):
+                if binedge_attrs is not None:
+                    msg = "passed both binedges as Axis instances and binedge_attrs"
+                    raise ValueError(msg)
+                b = binning
+            elif all(isinstance(ax, np.ndarray) for ax in binning):
+                b = [Histogram.Axis.from_edges(ax, binedge_attrs) for ax in binning]
+            elif all(isinstance(ax, tuple) for ax in binning):
+                b = [Histogram.Axis(None, *ax, True, binedge_attrs) for ax in binning]
+            else:
+                msg = "invalid binning object passed"
+                raise ValueError(msg)
+
+            if len(binning) != len(w.nda.shape):
+                msg = "binning and weight dimensions do not match"
+                raise ValueError(msg)
+            for i, ax in enumerate(b):
+                if ax.nbins != w.nda.shape[i]:
+                    msg = f"bin count does not match weight count along axis {i}"
+                    raise ValueError(msg)
+
+        b = Struct({f"axis_{i}": a for i, a in enumerate(b)})
+
+        super().__init__(
+            {"binning": b, "weights": w, "isdensity": Scalar(isdensity)},
+            attrs,
+        )
+
+    @property
+    def isdensity(self) -> bool:
+        return self["isdensity"].value
+
+    @property
+    def weights(self) -> Array:
+        return self["weights"]
+
+    @property
+    def binning(self) -> tuple[Histogram.Axis, ...]:
+        bins = sorted(self["binning"].items())
+        assert all(isinstance(v, Histogram.Axis) for k, v in bins)
+        return tuple(v for _, v in bins)
+
+    def __setitem__(self, name: str, obj: LGDO) -> None:
+        # do not allow for new attributes on this
+        msg = "histogram fields cannot be mutated"
+        raise TypeError(msg)
+
+    def __getattr__(self, name: str) -> None:
+        # do not allow for new attributes on this
+        msg = "histogram fields cannot be mutated"
+        raise TypeError(msg)
+
+    def add_field(self, name: str | int, obj: LGDO) -> None:  # noqa: ARG002
+        """
+        .. error ::
+
+            Not applicable: A histogram cannot be used as a struct
+        """
+        msg = "histogram fields cannot be mutated"
+        raise TypeError(msg)
+
+    def remove_field(self, name: str | int, delete: bool = False) -> None:  # noqa: ARG002
+        """
+        .. error ::
+
+            Not applicable: A histogram cannot be used as a struct
+        """
+        msg = "histogram fields cannot be mutated"
+        raise TypeError(msg)
+
+    def __str__(self) -> str:
+        string = "{\n"
+        for k, v in enumerate(self.binning):
+            string += f" 'axis_{k}': {v},\n"
+        string += "}"
+
+        attrs = self.getattrs()
+        if attrs:
+            string += f" with attrs={attrs}"
+
+        return string
+
+    def view_as(
+        self,
+        library: str,
+    ) -> tuple[NDArray] | hist.Hist:
+        r"""View the histogram data as a third-party format data structure.
+
+        This is typically a zero-copy or nearly zero-copy operation.
+
+        Supported third-party formats are:
+
+        - ``np``: returns a tuple of binning and an :class:`np.ndarray`, similar
+          to the return value of :func:`numpy.histogramdd`.
+        - ``hist``: returns an :class:`hist.Hist` that holds **a copy** of this
+          histogram's data.
+
+        Warning
+        -------
+        Viewing as ``hist`` will perform a copy of the stored histogram data.
+
+        Parameters
+        ----------
+        library
+            format of the returned data view.
+
+        See Also
+        --------
+        .LGDO.view_as
+        """
+        if library == "hist":
+            if self.isdensity:
+                msg = "hist.Hist cannot represent density histograms"
+                raise ValueError(msg)
+
+            hist_axes = []
+            for a in self.binning:
+                if not a.closedleft:
+                    msg = "hist.Hist cannot represent right-closed intervals"
+                    raise ValueError(msg)
+                if a.is_range:
+                    hist_ax = hist.axis.Regular(
+                        bins=a.nbins,
+                        start=a.first,
+                        stop=a.last,
+                        underflow=False,
+                        overflow=False,
+                    )
+                else:
+                    hist_ax = hist.axis.Variable(
+                        a.edges,
+                        underflow=False,
+                        overflow=False,
+                    )
+                hist_axes.append(hist_ax)
+
+            return hist.Hist(*hist_axes, data=self.weights.view_as("np"))
+
+        if library == "np":
+            edges = tuple([a.edges for a in self.binning])
+            return self.weights.view_as("np"), edges
+
+        msg = f"{library!r} is not a supported third-party format."
+        raise TypeError(msg)

{legend_pydataobj-1.8.1 → legend_pydataobj-1.9.0}/src/lgdo/types/table.py

@@ -168,7 +168,7 @@ class Table(Struct):
         self.add_field(name, obj, use_obj_size=use_obj_size)
 
     def remove_column(self, name: str, delete: bool = False) -> None:
-        """Alias for :meth:`.remove_field` using table terminology 'column'."""
+        """Alias for :meth:`Struct.remove_field` using table terminology 'column'."""
         super().remove_field(name, delete)
 
     def join(

{legend_pydataobj-1.8.1 → legend_pydataobj-1.9.0}/tests/conftest.py

@@ -26,5 +26,5 @@ def pytest_sessionfinish(session, exitstatus):  # noqa: ARG001
 @pytest.fixture(scope="session")
 def lgnd_test_data():
     ldata = LegendTestData()
-    ldata.checkout("8f55832")
+    ldata.checkout("82ad6c2")
     return ldata

{legend_pydataobj-1.8.1 → legend_pydataobj-1.9.0}/tests/lh5/test_lh5_datatype.py

@@ -33,6 +33,7 @@ def test_datatype2lgdo():
     assert d("struct{a,b,c,d}") == types.Struct
     assert d("struct{}") == types.Struct
     assert d("table{a,b,c,d}") == types.Table
+    assert d("struct{binning,weights,isdensity}") == types.Histogram
 
 
 def test_utils():