legend-pydataobj 1.5.0a1__py3-none-any.whl → 1.5.0a3__py3-none-any.whl

{legend_pydataobj-1.5.0a1.dist-info → legend_pydataobj-1.5.0a3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: legend_pydataobj
-Version: 1.5.0a1
+Version: 1.5.0a3
 Summary: LEGEND Python Data Objects
 Home-page: https://github.com/legend-exp/legend-pydataobj
 Author: The LEGEND Collaboration

{legend_pydataobj-1.5.0a1.dist-info → legend_pydataobj-1.5.0a3.dist-info}/RECORD

@@ -1,8 +1,8 @@
 lgdo/__init__.py,sha256=NVIX9H7OvWq42cyDze1knd5Nzn4JnVsC4jrue9KDJDs,2878
-lgdo/_version.py,sha256=hC2bqwplSBXWUhdSzihLLwKtZujXTeUmUPjwIfOCsho,413
-lgdo/cli.py,sha256=OYbhRYsMwOBFtyEDI_51eyE4etFC958kjG4GGmB50_M,1432
+lgdo/_version.py,sha256=Mog3Qr6q816oNESNv10fVvx3UitVasxa7LWRlekJWhs,413
+lgdo/cli.py,sha256=SW82mGdx9oY-xtD9Dr6yBVSQoTLrUq29nQmgjcCiqBM,1602
 lgdo/lgdo_utils.py,sha256=lO9ePOxAlSUNAslQLxptje18LhzDl55r9qRG69q1j8w,2546
-lgdo/lh5_store.py,sha256=27AU7smrXmSVxJNgq2f49g1jO3VYRCrATnYLZI-12XY,6336
+lgdo/lh5_store.py,sha256=v5p0oG17Y7CKsD7ruTkFwr-M4L6-8GGHVIuLwMYn74o,7320
 lgdo/logging.py,sha256=Nu3wgIoWN7cyUxuzPom5rMwFvTlBu8p8d9uONHDquRg,965
 lgdo/units.py,sha256=nbJ0JTNqlhHUXiBXT3k6qhRpSfMk5_9yW7EeC0dhMuQ,151
 lgdo/utils.py,sha256=MG594KOHhoTA0qAa7WkBrb3zjQHIlmkcpLosi5K6Fiw,4507
@@ -14,22 +14,22 @@ lgdo/compression/utils.py,sha256=YhxfJ_zvDu9I1BnjOsALR7SYbNohZNdm8HZ8IqTjd6w,106
 lgdo/compression/varlen.py,sha256=PL6xRZL0oq5ViE5993_RKoKuOPz8mvjwCRV2LuIQ_HA,15089
 lgdo/lh5/__init__.py,sha256=maNSqfdGQ5-kEUt2X2yVHqcSjPcQn-lSq3xnUhDAVJg,539
 lgdo/lh5/iterator.py,sha256=ncLbMzfrLihfX9Xqi-CdSHbYofEgGwdc36rfwA0r2oc,12245
-lgdo/lh5/store.py,sha256=nldGTCa2iA7aelOujchmLXH9xv2ofwS2OcstCcqUrgM,62317
+lgdo/lh5/store.py,sha256=jFid8PU3uTL-4QATACvCv8yr4msSWm6K61sVqF9Ku_E,62994
 lgdo/lh5/utils.py,sha256=2fE85GFxZVlO7ypWFPrTZSzDTSiSiyTJqZIu_rrqtBI,3638
 lgdo/types/__init__.py,sha256=1aqmN87_tu-NsSn-wbiKTauL2omSCcxUVC-BOlRpSUU,735
 lgdo/types/array.py,sha256=PY3TL1FRQZho_87A2S78kxtDchO8e8sm7Ny1uwLeOYY,6618
-lgdo/types/arrayofequalsizedarrays.py,sha256=Nyq0O6D24O--E9nAQ_wVxKRu5SvUJUXMfshWBfNbC08,4844
+lgdo/types/arrayofequalsizedarrays.py,sha256=PJx-_OH9gHrRDWNA8_olB62UQQq2EAVjirh2JxnDRRw,4936
 lgdo/types/encoded.py,sha256=M3XKv9ubbJO3X4A7UglYDLw0cjDOvRC1Tln7x_bwkYQ,15500
 lgdo/types/fixedsizearray.py,sha256=0f9nFjMGpQFU9U1_DKKlXXeApc4xzQQV-KZ14C2zEow,1510
 lgdo/types/lgdo.py,sha256=BTNbL2VrW-SBYdYRbWJ3-0XmIrvKJ2Rk1oJmhajW8Wc,2776
 lgdo/types/scalar.py,sha256=TtzJIPlqflMoOj0uzyxu3Ucf3ugKf7IDwUE4jLQ8_IE,1872
-lgdo/types/struct.py,sha256=NVALiGdmhYNHNgIUhaZtD43BZU5daDIJCssegIzyDVo,3902
-lgdo/types/table.py,sha256=OtqEBwXVDasOvezoTaC2xtXEV0cBm-WwyhGiPdBx9rU,15058
-lgdo/types/vectorofvectors.py,sha256=vho47nibjWKDej5sIrg3Nt9rTi3iP5r01AhM4JarPFw,27522
+lgdo/types/struct.py,sha256=7UStGTR3JHlh6lTvAv3LG5HHMLqTxbkW8VrxmYs1PCA,4058
+lgdo/types/table.py,sha256=itp_PLzT__wUCv9oy92xdHH5CjQGlZ9vUvrJmlrYUWY,15351
+lgdo/types/vectorofvectors.py,sha256=SH5SobtpNrom9ZfWX0UEWtkheDxjY8XBUhJOOdxAn9o,28078
 lgdo/types/waveformtable.py,sha256=d6ozsMkaLp9G6EqiDVC7NIFKpLOlzAn6REWuYnVeLyQ,9851
-legend_pydataobj-1.5.0a1.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-legend_pydataobj-1.5.0a1.dist-info/METADATA,sha256=ZUaJ8AZjDuOspezL2eDP613I_yupXwwB8Jb0N6AOi8g,3663
-legend_pydataobj-1.5.0a1.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-legend_pydataobj-1.5.0a1.dist-info/entry_points.txt,sha256=j22HoS-1cVhTtKJkDnKB49uNH0nEVER2Tpw-lVh1aws,41
-legend_pydataobj-1.5.0a1.dist-info/top_level.txt,sha256=KyR-EUloqiXcQ62IWnzBmtInDtvsHl4q2ZJAZgTcLXE,5
-legend_pydataobj-1.5.0a1.dist-info/RECORD,,
+legend_pydataobj-1.5.0a3.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+legend_pydataobj-1.5.0a3.dist-info/METADATA,sha256=jg4hFoeTGa11AgsYdapjm6zi36Sh6xb5Y0tRuAp8BYQ,3663
+legend_pydataobj-1.5.0a3.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+legend_pydataobj-1.5.0a3.dist-info/entry_points.txt,sha256=j22HoS-1cVhTtKJkDnKB49uNH0nEVER2Tpw-lVh1aws,41
+legend_pydataobj-1.5.0a3.dist-info/top_level.txt,sha256=KyR-EUloqiXcQ62IWnzBmtInDtvsHl4q2ZJAZgTcLXE,5
+legend_pydataobj-1.5.0a3.dist-info/RECORD,,

lgdo/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.5.0a1'
+__version__ = version = '1.5.0a3'
 __version_tuple__ = version_tuple = (1, 5, 0)

lgdo/cli.py

@@ -5,7 +5,7 @@ import sys
 
 import lgdo
 import lgdo.logging
-from lgdo import show
+from lgdo.lh5 import show
 
 
 def lh5ls():
@@ -26,7 +26,6 @@ def lh5ls():
     )
     parser.add_argument(
         "--debug",
-        "-d",
         action="store_true",
         help="""Increase the program verbosity to maximum""",
     )
@@ -39,6 +38,13 @@ def lh5ls():
     parser.add_argument(
         "--attributes", "-a", action="store_true", help="""Print HDF5 attributes too"""
     )
+    parser.add_argument(
+        "--depth",
+        "-d",
+        type=int,
+        default=None,
+        help="""Maximum tree depth of groups to print""",
+    )
 
     args = parser.parse_args()
 
@@ -53,4 +59,4 @@ def lh5ls():
         print(lgdo.__version__)  # noqa: T201
         sys.exit()
 
-    show(args.lh5_file, args.lh5_group, attrs=args.attributes)
+    show(args.lh5_file, args.lh5_group, attrs=args.attributes, depth=args.depth)

lgdo/lh5/store.py

@@ -12,6 +12,7 @@ import sys
 from bisect import bisect_left
 from collections import defaultdict
 from typing import Any, Union
+from warnings import warn
 
 import h5py
 import numba as nb
@@ -347,9 +348,7 @@ class LH5Store:
                     default = not field_mask[list(field_mask.keys())[0]]
                 field_mask = defaultdict(lambda: default, field_mask)
             elif isinstance(field_mask, (list, tuple)):
-                field_mask = defaultdict(
-                    lambda: False, {field: True for field in field_mask}
-                )
+                field_mask = defaultdict(bool, {field: True for field in field_mask})
             elif not isinstance(field_mask, defaultdict):
                 raise RuntimeError("bad field_mask of type", type(field_mask).__name__)
         elif field_mask is not None:
@@ -1337,6 +1336,7 @@ def show(
     attrs: bool = False,
     indent: str = "",
     header: bool = True,
+    depth: int | None = None,
 ) -> None:
     """Print a tree of LH5 file contents with LGDO datatype.
 
@@ -1352,6 +1352,8 @@ def show(
         indent the diagram with this string.
     header
         print `lh5_group` at the top of the diagram.
+    depth
+        maximum tree depth of groups to print
 
     Examples
     --------
@@ -1367,6 +1369,10 @@ def show(
     │   └── values · array_of_equalsized_arrays<1,1>{real}
     └── wf_std · array<1>{real}
     """
+    # check tree depth if we are using it
+    if depth is not None and depth <= 0:
+        return
+
     # open file
     if isinstance(lh5_file, str):
         lh5_file = h5py.File(expand_path(lh5_file), "r")
@@ -1422,6 +1428,7 @@ def show(
                 indent=indent + ("    " if killme else "│   "),
                 header=False,
                 attrs=attrs,
+                depth=depth - 1 if depth else None,
             )
 
         # break or move to next key
@@ -1461,6 +1468,14 @@ def load_nda(
         Each entry contains the data for the specified parameter concatenated
         over all files in `f_list`.
     """
+    warn(
+        "load_nda() is deprecated. "
+        "Please replace it with LH5Store.read(...).view_as('np'). "
+        "load_nda() will be removed in a future release.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+
     if isinstance(f_list, str):
         f_list = [f_list]
         if idx_list is not None:
@@ -1515,6 +1530,13 @@ def load_dfs(
         all data for the associated parameters concatenated over all files in
         `f_list`.
     """
+    warn(
+        "load_dfs() is deprecated. "
+        "Please replace it with LH5Store.read(...).view_as('pd'). "
+        "load_dfs() will be removed in a future release.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
     return pd.DataFrame(
         load_nda(f_list, par_list, lh5_group=lh5_group, idx_list=idx_list)
     )

lgdo/lh5_store.py

@@ -131,6 +131,37 @@ class LH5Store(lh5.LH5Store):
         )
         super().__init__(base_path, keep_open)
 
+    def read_object(
+        self,
+        name: str,
+        lh5_file: str | h5py.File | list[str | h5py.File],
+        **kwargs,
+    ) -> tuple[LGDO, int]:
+        warn(
+            "LH5Store.read_object() has been renamed to LH5Store.read(), "
+            "Please update your code."
+            "LH5Store.read_object() will be removed in a future release.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return super().read(self, name, lh5_file, **kwargs)
+
+    def write_object(
+        self,
+        obj: LGDO,
+        name: str,
+        lh5_file: str | h5py.File,
+        **kwargs,
+    ) -> tuple[LGDO, int]:
+        warn(
+            "LH5Store.write_object() has been renamed to LH5Store.write(), "
+            "Please update your code."
+            "LH5Store.write_object() will be removed in a future release.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return super().read(self, obj, name, lh5_file, **kwargs)
+
 
 def load_dfs(
     f_list: str | list[str],

lgdo/types/arrayofequalsizedarrays.py

@@ -70,6 +70,8 @@ class ArrayOfEqualSizedArrays(Array):
             if nda is None:
                 s = shape
             else:
+                if not isinstance(nda, np.ndarray):
+                    nda = np.array(nda)
                 s = nda.shape
             self.dims = (1, len(s) - 1)
         else:

lgdo/types/struct.py

@@ -60,7 +60,13 @@ class Struct(LGDO, dict):
         return self.add_field(name, obj)
 
     def __getattr__(self, name: str) -> LGDO:
-        return self.__getitem__(name)
+        if hasattr(super(), name):
+            return super().__getattr__(name)
+
+        if name in self.keys():
+            return super().__getitem__(name)
+
+        raise AttributeError(name)
 
     def remove_field(self, name: str | int, delete: bool = False) -> None:
         """Remove a field from the table.

lgdo/types/table.py

@@ -5,8 +5,7 @@ equal length and corresponding utilities.
 from __future__ import annotations
 
 import logging
-import re
-from typing import Any
+from typing import Any, Mapping
 from warnings import warn
 
 import awkward as ak
@@ -18,6 +17,7 @@ from pandas.io.formats import format as fmt
 from .array import Array
 from .arrayofequalsizedarrays import ArrayOfEqualSizedArrays
 from .lgdo import LGDO
+from .scalar import Scalar
 from .struct import Struct
 from .vectorofvectors import VectorOfVectors
 
@@ -38,8 +38,6 @@ class Table(Struct):
     :meth:`__len__` to access valid data, which returns the ``size`` attribute.
     """
 
-    # TODO: overload getattr to allow access to fields as object attributes?
-
     def __init__(
         self,
         size: int = None,
@@ -217,102 +215,114 @@ class Table(Struct):
         )
         return self.view_as(library="pd", cols=cols, prefix=prefix)
 
-    def eval(self, expr_config: dict) -> Table:
-        """Apply column operations to the table and return a new table holding
-        the resulting columns.
+    def eval(
+        self,
+        expr: str,
+        parameters: Mapping[str, str] = None,
+    ) -> LGDO:
+        """Apply column operations to the table and return a new LGDO.
 
-        Currently defers all the job to :meth:`numexpr.evaluate`. This
-        might change in the future.
+        Internally uses :func:`numexpr.evaluate` if dealing with columns
+        representable as NumPy arrays or :func:`eval` if
+        :class:`.VectorOfVectors` are involved. In the latter case, the VoV
+        columns are viewed as :class:`ak.Array` and the respective routines are
+        therefore available.
 
         Parameters
         ----------
-        expr_config
-            dictionary that configures expressions according the following
-            specification:
-
-            .. code-block:: js
-
-                {
-                    "O1": {
-                        "expression": "p1 + p2 * a**2",
-                        "parameters": {
-                            "p1": 2,
-                            "p2": 3
-                        }
-                    },
-                    "O2": {
-                        "expression": "O1 - b"
-                    }
-                    // ...
-                }
-
-            where:
-
-            - ``expression`` is an expression string supported by
-              :meth:`numexpr.evaluate` (see also `here
-              <https://numexpr.readthedocs.io/projects/NumExpr3/en/latest/index.html>`_
-              for documentation). Note: because of internal limitations,
-              reduction operations must appear the last in the stack.
-            - ``parameters`` is a dictionary of function parameters. Passed to
-              :meth:`numexpr.evaluate`` as `local_dict` argument.
-
-
-        Warning
-        -------
-        Blocks in `expr_config` must be ordered according to mutual dependency.
+        expr
+            if the expression only involves non-:class:`.VectorOfVectors`
+            columns, the syntax is the one supported by
+            :func:`numexpr.evaluate` (see `here
+            <https://numexpr.readthedocs.io/projects/NumExpr3/en/latest/index.html>`_
+            for documentation). Note: because of internal limitations,
+            reduction operations must appear the last in the stack. If at least
+            one considered column is a :class:`.VectorOfVectors`, plain
+            :func:`eval` is used and :class:`ak.Array` transforms can be used
+            through the ``ak.`` prefix. (NumPy functions are analogously
+            accessible through ``np.``). See also examples below.
+        parameters
+            a dictionary of function parameters. Passed to
+            :func:`numexpr.evaluate`` as `local_dict` argument or to
+            :func:`eval` as `locals` argument.
+
+        Examples
+        --------
+        >>> import lgdo
+        >>> tbl = lgdo.Table(
+        ...   col_dict={
+        ...     "a": lgdo.Array([1, 2, 3]),
+        ...     "b": lgdo.VectorOfVectors([[5], [6, 7], [8, 9, 0]]),
+        ...   }
+        ... )
+        >>> print(tbl.eval("a + b"))
+        [[6],
+         [8 9],
+         [11 12  3],
+        ]
+        >>> print(tbl.eval("np.sum(a) + ak.sum(b)"))
+        41
         """
-        out_tbl = Table(size=self.size)
-        for out_var, spec in expr_config.items():
-            in_vars = {}
-            # Find all valid python variables in expression (e.g "a*b+sin(Cool)" --> ['a','b','sin','Cool'])
-            for elem in re.findall(r"\s*[A-Za-z_]\w*\s*", spec["expression"]):
-                elem = elem.strip()
-                if elem in self:  # check if the variable comes from dsp
-                    in_vars[elem] = self[elem]
-                elif (
-                    elem in out_tbl.keys()
-                ):  # if not try from previously processed data, else ignore since it is e.g sin func
-                    in_vars[elem] = out_tbl[elem]
-
+        if parameters is None:
+            parameters = {}
+
+        # get the valid python variable names in the expression
+        c = compile(expr, "0vbb is real!", "eval")
+
+        # make a dictionary of low-level objects (numpy or awkward)
+        # for later computation
+        self_unwrap = {}
+        has_ak = False
+        for obj in c.co_names:
+            if obj in self.keys():
+                if isinstance(self[obj], VectorOfVectors):
+                    self_unwrap[obj] = self[obj].view_as("ak", with_units=False)
+                    has_ak = True
                 else:
-                    continue
-                # get the nda if it is an Array instance
-                if isinstance(in_vars[elem], Array):
-                    in_vars[elem] = in_vars[elem].nda
-                # No vector of vectors support yet
-                elif isinstance(in_vars[elem], VectorOfVectors):
-                    raise TypeError("Data of type VectorOfVectors not supported (yet)")
+                    self_unwrap[obj] = self[obj].view_as("np", with_units=False)
 
+        # use numexpr if we are only dealing with numpy data types
+        if not has_ak:
             out_data = ne.evaluate(
-                f"{spec['expression']}",
-                local_dict=dict(in_vars, **spec["parameters"])
-                if "parameters" in spec
-                else in_vars,
-            )  # Division is chosen by __future__.division in the interpreter
-
-            # smart way to find right LGDO data type:
-
-            # out_data has one row and this row has a scalar (eg scalar product of two rows)
-            if len(np.shape(out_data)) == 0:
-                out_data = Array(nda=out_data)
-
-            # out_data has scalar in each row
-            elif len(np.shape(out_data)) == 1:
-                out_data = Array(nda=out_data)
-
-            # out_data is  like
-            elif len(np.shape(out_data)) == 2:
-                out_data = ArrayOfEqualSizedArrays(nda=out_data)
-
-            # higher order data (eg matrix product of ArrayOfEqualSizedArrays) not supported yet
+                expr,
+                local_dict=(self_unwrap | parameters),
+            )
+
+            # need to convert back to LGDO
+            # np.evaluate should always return a numpy thing?
+            if out_data.ndim == 0:
+                return Scalar(out_data.item())
+            elif out_data.ndim == 1:
+                return Array(out_data)
+            elif out_data.ndim == 2:
+                return ArrayOfEqualSizedArrays(nda=out_data)
             else:
-                ValueError(
-                    f"Calculation resulted in {len(np.shape(out_data))-1}-D row which is not supported yet"
+                msg = (
+                    f"evaluation resulted in {out_data.ndim}-dimensional data, "
+                    "I don't know which LGDO this corresponds to"
                 )
+                raise RuntimeError(msg)
 
-            out_tbl.add_column(out_var, out_data)
+        else:
+            # resort to good ol' eval()
+            globs = {"ak": ak, "np": np}
+            out_data = eval(expr, globs, (self_unwrap | parameters))
+
+            # need to convert back to LGDO
+            if isinstance(out_data, ak.Array):
+                if out_data.ndim == 1:
+                    return Array(out_data.to_numpy())
+                else:
+                    return VectorOfVectors(out_data)
 
-        return out_tbl
+            if np.isscalar(out_data):
+                return Scalar(out_data)
+            else:
+                msg = (
+                    f"evaluation resulted in a {type(out_data)} object, "
+                    "I don't know which LGDO this corresponds to"
+                )
+                raise RuntimeError(msg)
 
     def __str__(self):
         opts = fmt.get_dataframe_repr_params()

lgdo/types/vectorofvectors.py

@@ -35,7 +35,7 @@ class VectorOfVectors(LGDO):
 
     def __init__(
         self,
-        listoflists: list[list[int | float]] = None,
+        array: ak.Array | list[list[int | float]] = None,
         flattened_data: Array | NDArray = None,
         cumulative_length: Array | NDArray = None,
         shape_guess: tuple[int, int] = None,
@@ -46,9 +46,10 @@ class VectorOfVectors(LGDO):
         """
         Parameters
         ----------
-        listoflists
-            create a VectorOfVectors out of a Python list of lists. Takes
-            priority over `flattened_data` and `cumulative_length`.
+        array
+            create a ``VectorOfVectors`` out of a Python list of lists or an
+            :class:`ak.Array`. Takes priority over `flattened_data` and
+            `cumulative_length`.
         flattened_data
             if not ``None``, used as the internal array for
             `self.flattened_data`.  Otherwise, an internal `flattened_data` is
@@ -67,30 +68,43 @@ class VectorOfVectors(LGDO):
             of `flattened_data` if it was not supplied.
         dtype
             sets the type of data stored in `flattened_data`. Required if
-            `flattened_data` and `listoflists` are ``None``.
+            `flattened_data` and `array` are ``None``.
         fill_val
             fill all of `self.flattened_data` with this value.
         attrs
             a set of user attributes to be carried along with this LGDO.
         """
-        if listoflists is not None:
-            cl_nda = np.cumsum([len(ll) for ll in listoflists])
-            if dtype is None:
-                if len(cl_nda) == 0 or cl_nda[-1] == 0:
-                    raise ValueError("listoflists can't be empty with dtype=None!")
-                else:
-                    # Set dtype from the first element in the list
-                    # Find it efficiently, allowing for zero-length lists as some of the entries
-                    first_element = next(itertools.chain.from_iterable(listoflists))
-                    dtype = type(first_element)
+        if array is not None:
+            if isinstance(array, ak.Array):
+                if array.ndim != 2:
+                    raise ValueError(
+                        "cannot initialize a VectorOfVectors with "
+                        f"{array.ndim}-dimensional data"
+                    )
 
-            self.dtype = np.dtype(dtype)
-            self.cumulative_length = Array(cl_nda)
-            self.flattened_data = Array(
-                np.fromiter(
-                    itertools.chain.from_iterable(listoflists), dtype=self.dtype
+                form, length, container = ak.to_buffers(array)
+
+                return self.__init__(
+                    flattened_data=container["node1-data"],
+                    cumulative_length=container["node0-offsets"][1:],
+                )
+
+            else:
+                cl_nda = np.cumsum([len(ll) for ll in array])
+                if dtype is None:
+                    if len(cl_nda) == 0 or cl_nda[-1] == 0:
+                        raise ValueError("array can't be empty with dtype=None!")
+                    else:
+                        # Set dtype from the first element in the list
+                        # Find it efficiently, allowing for zero-length lists as some of the entries
+                        first_element = next(itertools.chain.from_iterable(array))
+                        dtype = type(first_element)
+
+                self.dtype = np.dtype(dtype)
+                self.cumulative_length = Array(cl_nda)
+                self.flattened_data = Array(
+                    np.fromiter(itertools.chain.from_iterable(array), dtype=self.dtype)
                 )
-            )
 
         else:
             if cumulative_length is None: