legend-pydataobj 1.6.2__tar.gz → 1.7.0__tar.gz

{legend_pydataobj-1.6.2 → legend_pydataobj-1.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: legend_pydataobj
-Version: 1.6.2
+Version: 1.7.0
 Summary: LEGEND Python Data Objects
 Author: The LEGEND Collaboration
 Maintainer: The LEGEND Collaboration

{legend_pydataobj-1.6.2 → legend_pydataobj-1.7.0}/src/legend_pydataobj.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: legend_pydataobj
-Version: 1.6.2
+Version: 1.7.0
 Summary: LEGEND Python Data Objects
 Author: The LEGEND Collaboration
 Maintainer: The LEGEND Collaboration

{legend_pydataobj-1.6.2 → legend_pydataobj-1.7.0}/src/lgdo/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.6.2'
-__version_tuple__ = version_tuple = (1, 6, 2)
+__version__ = version = '1.7.0'
+__version_tuple__ = version_tuple = (1, 7, 0)

{legend_pydataobj-1.6.2 → legend_pydataobj-1.7.0}/src/lgdo/cli.py

@@ -52,6 +52,11 @@ def lh5ls(args=None):
         default=None,
         help="""Maximum tree depth of groups to print""",
     )
+    parser.add_argument(
+        "--detail",
+        action="store_true",
+        help="""Print details about datasets""",
+    )
 
     args = parser.parse_args(args)
 
@@ -66,7 +71,13 @@ def lh5ls(args=None):
         print(__version__)  # noqa: T201
         sys.exit()
 
-    lh5.show(args.lh5_file, args.lh5_group, attrs=args.attributes, depth=args.depth)
+    lh5.show(
+        args.lh5_file,
+        args.lh5_group,
+        attrs=args.attributes,
+        depth=args.depth,
+        detail=args.detail,
+    )
 
 
 def lh5concat(args=None):

{legend_pydataobj-1.6.2 → legend_pydataobj-1.7.0}/src/lgdo/lh5/_serializers/write/array.py

@@ -10,7 +10,7 @@ from ...exceptions import LH5EncodeError
 
 log = logging.getLogger(__name__)
 
-DEFAULT_HDF5_SETTINGS: dict[str, ...] = {"shuffle": True, "compression": "lzf"}
+DEFAULT_HDF5_SETTINGS: dict[str, ...] = {"shuffle": True, "compression": "gzip"}
 
 
 def _h5_write_array(

{legend_pydataobj-1.6.2 → legend_pydataobj-1.7.0}/src/lgdo/lh5/tools.py

@@ -87,6 +87,7 @@ def show(
     indent: str = "",
     header: bool = True,
     depth: int | None = None,
+    detail: bool = False,
 ) -> None:
     """Print a tree of LH5 file contents with LGDO datatype.
 
@@ -104,6 +105,8 @@ def show(
         print `lh5_group` at the top of the diagram.
     depth
         maximum tree depth of groups to print
+    detail
+        whether to print additional information about how the data is stored
 
     Examples
     --------
@@ -171,6 +174,26 @@ def show(
 
         print(f"{indent}{char} \033[1m{key}\033[0m · {dtype} {_attrs}")  # noqa: T201
 
+        if detail and isinstance(val, h5py.Dataset):
+            char = "|       "
+            if killme:
+                char = "        "
+            toprint = f"{indent}{char}"
+            try:
+                toprint += f"\033[3mdtype\033[0m={val.dtype}"
+                toprint += f", \033[3mshape\033[0m={val.shape}"
+                toprint += f", \033[3mnbytes\033[0m={utils.fmtbytes(val.nbytes)}"
+                if (chunkshape := val.chunks) is None:
+                    toprint += ", \033[3mnumchunks\033[0m=contiguous"
+                else:
+                    toprint += f", \033[3mnumchunks\033[0m={val.id.get_num_chunks()}"
+                    toprint += f", \033[3mchunkshape\033[0m={chunkshape}"
+                toprint += f", \033[3mcompression\033[0m={val.compression}"
+            except TypeError:
+                toprint += "(scalar)"
+
+            print(toprint)  # noqa: T201
+
         # if it's a group, call this function recursively
         if isinstance(val, h5py.Group):
             show(
@@ -179,6 +202,7 @@ def show(
                 header=False,
                 attrs=attrs,
                 depth=depth - 1 if depth else None,
+                detail=detail,
             )
 
         # break or move to next key

{legend_pydataobj-1.6.2 → legend_pydataobj-1.7.0}/src/lgdo/lh5/utils.py

@@ -221,3 +221,13 @@ def expand_path(
         return paths[0]
 
     return paths
+
+
+# https://stackoverflow.com/a/1094933
+def fmtbytes(num, suffix="B"):
+    """Returns formatted f-string for printing human-readable number of bytes."""
+    for unit in ("", "k", "M", "G", "T", "P", "E", "Z"):
+        if abs(num) < 1024.0:
+            return f"{num:3.1f} {unit}{suffix}"
+        num /= 1024.0
+    return f"{num:.1f} Y{suffix}"

{legend_pydataobj-1.6.2 → legend_pydataobj-1.7.0}/src/lgdo/types/struct.py

@@ -6,6 +6,7 @@ utilities.
 from __future__ import annotations
 
 import logging
+from collections.abc import Mapping
 from typing import Any
 
 import numpy as np
@@ -24,8 +25,8 @@ class Struct(LGDO, dict):
 
     def __init__(
         self,
-        obj_dict: dict[str, LGDO] | None = None,
-        attrs: dict[str, Any] | None = None,
+        obj_dict: Mapping[str, LGDO] | None = None,
+        attrs: Mapping[str, Any] | None = None,
     ) -> None:
         """
         Parameters
@@ -37,8 +38,25 @@ class Struct(LGDO, dict):
             a set of user attributes to be carried along with this LGDO.
         """
         if obj_dict is not None:
-            self.update(obj_dict)
-
+            for k, v in obj_dict.items():
+                # check if value is another mapping-like object
+                # initialize another struct (or derived class) in such a case
+                if not isinstance(v, LGDO) and isinstance(v, Mapping):
+                    # NOTE: calling self.__new__() and then self.__init__() allows for polymorphism
+                    # but is there a better way?
+                    nested = self.__new__(type(self), v)
+                    nested.__init__(v)
+                    super().update({k: nested})
+                else:
+                    # otherwise object must be an LGDO
+                    if not isinstance(v, LGDO):
+                        msg = f"value of '{k}' ({v!r}) is not an LGDO or a dictionary"
+                        raise ValueError(msg)
+
+                    # assign
+                    super().update({k: v})
+
+        # call LGDO constructor to setup attributes
         super().__init__(attrs)
 
     def datatype_name(self) -> str:

{legend_pydataobj-1.6.2 → legend_pydataobj-1.7.0}/src/lgdo/types/table.py

@@ -42,9 +42,9 @@ class Table(Struct):
 
     def __init__(
         self,
+        col_dict: Mapping[str, LGDO] | pd.DataFrame | ak.Array | None = None,
         size: int | None = None,
-        col_dict: dict[str, LGDO] | None = None,
-        attrs: dict[str, Any] | None = None,
+        attrs: Mapping[str, Any] | None = None,
     ) -> None:
         r"""
         Parameters
@@ -56,11 +56,14 @@ class Table(Struct):
             determined from the length of the first array in `col_dict`. If
             neither is provided, a default length of 1024 is used.
         col_dict
-            instantiate this table using the supplied named array-like LGDO's.
-            Note 1: no copy is performed, the objects are used directly.
-            Note 2: if `size` is not ``None``, all arrays will be resized to
-            match it.  Note 3: if the arrays have different lengths, all will
-            be resized to match the length of the first array.
+            instantiate this table using the supplied mapping of column names
+            and array-like objects. Supported input types are: mapping of
+            strings to LGDOs, :class:`pd.DataFrame` and :class:`ak.Array`.
+            Note 1: no copy is performed, the objects are used directly (unless
+            :class:`ak.Array` is provided).  Note 2: if `size` is not ``None``,
+            all arrays will be resized to match it.  Note 3: if the arrays have
+            different lengths, all will be resized to match the length of the
+            first array.
         attrs
             A set of user attributes to be carried along with this LGDO.
 
@@ -68,14 +71,20 @@ class Table(Struct):
         -----
         the :attr:`loc` attribute is initialized to 0.
         """
+        if isinstance(col_dict, pd.DataFrame):
+            col_dict = {k: Array(v) for k, v in col_dict.items()}
+
+        if isinstance(col_dict, ak.Array):
+            col_dict = _ak_to_lgdo_or_col_dict(col_dict)
+
+        # call Struct constructor
         super().__init__(obj_dict=col_dict, attrs=attrs)
 
         # if col_dict is not empty, set size according to it
         # if size is also supplied, resize all fields to match it
         # otherwise, warn if the supplied fields have varying size
         if col_dict is not None and len(col_dict) > 0:
-            do_warn = size is None
-            self.resize(new_size=size, do_warn=do_warn)
+            self.resize(new_size=size, do_warn=(size is None))
 
         # if no col_dict, just set the size (default to 1024)
         else:
@@ -479,3 +488,11 @@ class Table(Struct):
 
         msg = f"{library!r} is not a supported third-party format."
         raise TypeError(msg)
+
+
+def _ak_to_lgdo_or_col_dict(array: ak.Array):
+    if isinstance(array.type.content, ak.types.RecordType):
+        return {field: _ak_to_lgdo_or_col_dict(array[field]) for field in array.fields}
+    if isinstance(array.type.content, ak.types.NumpyType):
+        return Array(ak.to_numpy(array))
+    return VectorOfVectors(array)

{legend_pydataobj-1.6.2 → legend_pydataobj-1.7.0}/src/lgdo/types/vectorofvectors.py

@@ -302,26 +302,23 @@ class VectorOfVectors(LGDO):
          [3],
         ]
         """
-        if self.ndim == 2:
-            vidx = self.cumulative_length
-            old_s = len(self)
-            dlen = new_size - old_s
-            csum = vidx[-1] if len(self) > 0 else 0
-
-            # first resize the cumulative length
-            self.cumulative_length.resize(new_size)
-
-            # if new_size > size, new elements are filled with zeros, let's fix
-            # that
-            if dlen > 0:
-                self.cumulative_length[old_s:] = csum
-
-            # then resize the data array
-            # if dlen > 0 this has no effect
-            if len(self.cumulative_length) > 0:
-                self.flattened_data.resize(self.cumulative_length[-1])
-        else:
-            raise NotImplementedError
+        vidx = self.cumulative_length
+        old_s = len(self)
+        dlen = new_size - old_s
+        csum = vidx[-1] if len(self) > 0 else 0
+
+        # first resize the cumulative length
+        self.cumulative_length.resize(new_size)
+
+        # if new_size > size, new elements are filled with zeros, let's fix
+        # that
+        if dlen > 0:
+            self.cumulative_length[old_s:] = csum
+
+        # then resize the data array
+        # if dlen > 0 this has no effect
+        if len(self.cumulative_length) > 0:
+            self.flattened_data.resize(self.cumulative_length[-1])
 
     def append(self, new: NDArray) -> None:
         """Append a 1D vector `new` at the end.

{legend_pydataobj-1.6.2 → legend_pydataobj-1.7.0}/tests/types/test_struct.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import pytest
+
 import lgdo
 
 
@@ -26,6 +28,25 @@ def test_init():
     assert dict(struct) == obj_dict
     assert struct.attrs == attrs | {"datatype": "struct{scalar1}"}
 
+    with pytest.raises(ValueError):
+        lgdo.Struct(obj_dict={"scalar1": 1})
+
+    with pytest.raises(ValueError):
+        lgdo.Struct(obj_dict={"scalar1": lgdo.Scalar(value=10), "thing": int})
+
+
+def test_init_nested():
+    obj_dict = {
+        "scalar1": lgdo.Scalar(10),
+        "struct1": {"field1": lgdo.Scalar(11), "field2": lgdo.Array([1, 2, 3, 4])},
+    }
+    struct = lgdo.Struct(obj_dict)
+    assert isinstance(struct.struct1, lgdo.Struct)
+    assert isinstance(struct.struct1.field1, lgdo.Scalar)
+    assert struct.struct1.field1.value == 11
+    assert isinstance(struct.struct1.field2, lgdo.Array)
+    assert struct.struct1.field2 == lgdo.Array([1, 2, 3, 4])
+
 
 def test_add_field():
     struct = lgdo.Struct()

{legend_pydataobj-1.6.2 → legend_pydataobj-1.7.0}/tests/types/test_table.py

@@ -31,6 +31,48 @@ def test_init():
     assert tbl.size == 3
 
 
+def test_init_nested():
+    col_dict = {
+        "a": lgdo.Array(nda=np.array([1, 2, 3, 4])),
+        "b": lgdo.Array(nda=np.array([5, 6, 7, 8])),
+        "c": {
+            "f1": lgdo.Array([1, 2, 3, 4]),
+            "f2": lgdo.Array([1, 2, 3, 4]),
+        },
+    }
+
+    tbl = Table(col_dict=col_dict)
+    assert isinstance(tbl.c, Table)
+    assert isinstance(tbl.c.f1, lgdo.Array)
+    assert tbl.c.f1 == lgdo.Array([1, 2, 3, 4])
+
+
+def test_pandas_df_init():
+    df = pd.DataFrame({"a": [1, 2, 3, 4], "b": [5, 6, 7, 8]})
+    tbl = Table(col_dict=df)
+    assert sorted(tbl.keys()) == ["a", "b"]
+    assert isinstance(tbl.a, lgdo.Array)
+    assert isinstance(tbl.b, lgdo.Array)
+    assert tbl.a == lgdo.Array([1, 2, 3, 4])
+    assert tbl.b == lgdo.Array([5, 6, 7, 8])
+
+
+def test_ak_array_init():
+    array = ak.Array(
+        {
+            "a": [1, 2, 3, 4],
+            "b": [[1, 2], [3], [4], [5, 6, 7]],
+            "c": {"f1": [[], [5], [3, 7, 6], []], "f2": [5, 6, 7, 8]},
+        }
+    )
+    tbl = Table(array)
+    assert isinstance(tbl.a, lgdo.Array)
+    assert isinstance(tbl.b, lgdo.VectorOfVectors)
+    assert isinstance(tbl.c, Table)
+    assert isinstance(tbl.c.f1, lgdo.VectorOfVectors)
+    assert isinstance(tbl.c.f2, lgdo.Array)
+
+
 def test_datatype_name():
     tbl = Table()
     assert tbl.datatype_name() == "table"
@@ -95,7 +137,7 @@ def test_join():
 
 
 def test_view_as():
-    tbl = Table(3)
+    tbl = Table(size=3)
     tbl.add_column("a", lgdo.Array(np.array([1, 2, 3]), attrs={"units": "m"}))
     tbl.add_column("b", lgdo.Array(np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]])))
     tbl.add_column(

{legend_pydataobj-1.6.2 → legend_pydataobj-1.7.0}/tests/types/test_vectorofvectors.py

@@ -174,20 +174,37 @@ def test_getitem(testvov):
 
 
 def test_resize(testvov):
-    testvov = testvov.v2d
-
-    testvov.resize(3)
-    assert ak.is_valid(testvov.view_as("ak"))
-    assert len(testvov.cumulative_length) == 3
-    assert len(testvov.flattened_data) == testvov.cumulative_length[-1]
-    assert testvov == VectorOfVectors([[1, 2], [3, 4, 5], [2]])
+    vov = testvov.v2d
+
+    vov.resize(3)
+    assert ak.is_valid(vov.view_as("ak"))
+    assert len(vov.cumulative_length) == 3
+    assert len(vov.flattened_data) == vov.cumulative_length[-1]
+    assert vov == VectorOfVectors([[1, 2], [3, 4, 5], [2]])
+
+    vov.resize(5)
+    assert ak.is_valid(vov.view_as("ak"))
+    assert len(vov) == 5
+    assert len(vov[3]) == 0
+    assert len(vov[4]) == 0
+    assert vov == VectorOfVectors([[1, 2], [3, 4, 5], [2], [], []])
+
+    vov = testvov.v3d
+
+    vov.resize(3)
+    assert ak.is_valid(vov.view_as("ak"))
+    assert len(vov.cumulative_length) == 3
+    assert len(vov.flattened_data) == vov.cumulative_length[-1]
+    assert vov == VectorOfVectors(
+        [[[1, 2], [3, 4, 5]], [[2], [4, 8, 9, 7]], [[5, 3, 1]]]
+    )
 
-    testvov.resize(5)
-    assert ak.is_valid(testvov.view_as("ak"))
-    assert len(testvov) == 5
-    assert len(testvov[3]) == 0
-    assert len(testvov[4]) == 0
-    assert testvov == VectorOfVectors([[1, 2], [3, 4, 5], [2], [], []])
+    vov.resize(5)
+    assert ak.is_valid(vov.view_as("ak"))
+    assert len(vov) == 5
+    assert vov == VectorOfVectors(
+        [[[1, 2], [3, 4, 5]], [[2], [4, 8, 9, 7]], [[5, 3, 1]], [], []]
+    )
 
     v = VectorOfVectors(dtype="i")
     v.resize(3)