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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: legend_pydataobj
-Version: 1.6.2
+Version: 1.7.1
 Summary: LEGEND Python Data Objects
 Author: The LEGEND Collaboration
 Maintainer: The LEGEND Collaboration
@@ -707,7 +707,7 @@ Requires-Dist: numexpr
 Requires-Dist: numpy>=1.21
 Requires-Dist: pandas>=1.4.4
 Requires-Dist: parse
-Requires-Dist: pint
+Requires-Dist: pint!=0.24
 Requires-Dist: pint-pandas
 Provides-Extra: all
 Requires-Dist: legend-pydataobj[docs,test]; extra == "all"

{legend_pydataobj-1.6.2 → legend_pydataobj-1.7.1}/pyproject.toml

@@ -41,7 +41,7 @@ dependencies = [
     "numpy>=1.21",
     "pandas>=1.4.4",
     "parse",
-    "pint",
+    "pint!=0.24",
     "pint-pandas",
 ]
 dynamic = [

{legend_pydataobj-1.6.2 → legend_pydataobj-1.7.1}/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.1
 Summary: LEGEND Python Data Objects
 Author: The LEGEND Collaboration
 Maintainer: The LEGEND Collaboration
@@ -707,7 +707,7 @@ Requires-Dist: numexpr
 Requires-Dist: numpy>=1.21
 Requires-Dist: pandas>=1.4.4
 Requires-Dist: parse
-Requires-Dist: pint
+Requires-Dist: pint!=0.24
 Requires-Dist: pint-pandas
 Provides-Extra: all
 Requires-Dist: legend-pydataobj[docs,test]; extra == "all"

{legend_pydataobj-1.6.2 → legend_pydataobj-1.7.1}/src/legend_pydataobj.egg-info/requires.txt

@@ -8,7 +8,7 @@ numexpr
 numpy>=1.21
 pandas>=1.4.4
 parse
-pint
+pint!=0.24
 pint-pandas
 
 [all]

{legend_pydataobj-1.6.2 → legend_pydataobj-1.7.1}/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.1'
+__version_tuple__ = version_tuple = (1, 7, 1)

{legend_pydataobj-1.6.2 → legend_pydataobj-1.7.1}/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.1}/src/lgdo/lh5/_serializers/read/composite.py

@@ -56,7 +56,7 @@ def _h5_read_lgdo(
         lh5_file = list(h5f)
         n_rows_read = 0
 
-        for i, h5f in enumerate(lh5_file):
+        for i, _h5f in enumerate(lh5_file):
             if isinstance(idx, list) and len(idx) > 0 and not np.isscalar(idx[0]):
                 # a list of lists: must be one per file
                 idx_i = idx[i]
@@ -65,7 +65,7 @@ def _h5_read_lgdo(
                 if not (isinstance(idx, tuple) and len(idx) == 1):
                     idx = (idx,)
                 # idx is a long continuous array
-                n_rows_i = read_n_rows(name, h5f)
+                n_rows_i = read_n_rows(name, _h5f)
                 # find the length of the subset of idx that contains indices
                 # that are less than n_rows_i
                 n_rows_to_read_i = bisect.bisect_left(idx[0], n_rows_i)
@@ -78,7 +78,7 @@ def _h5_read_lgdo(
 
             obj_buf, n_rows_read_i = _h5_read_lgdo(
                 name,
-                h5f,
+                _h5f,
                 start_row=start_row,
                 n_rows=n_rows_i,
                 idx=idx_i,

{legend_pydataobj-1.6.2 → legend_pydataobj-1.7.1}/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.1}/src/lgdo/lh5/_serializers/write/vector_of_vectors.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 import logging
 
+import numpy as np
+
 from .... import types
 from ... import utils
 from ...exceptions import LH5EncodeError
@@ -31,12 +33,15 @@ def _h5_write_vector_of_vectors(
 
     # if appending we need to add an appropriate offset to the
     # cumulative lengths as appropriate for the in-file object
-    offset = 0  # declare here because we have to subtract it off at the end
+    # declare here because we have to subtract it off at the end
+    offset = np.int64(0)
     if (wo_mode in ("a", "o")) and "cumulative_length" in group:
         len_cl = len(group["cumulative_length"])
+        # if append, ignore write_start and set it to total number of vectors
         if wo_mode == "a":
             write_start = len_cl
         if len_cl > 0:
+            # set offset to correct number of elements in flattened_data until write_start
             offset = group["cumulative_length"][write_start - 1]
 
     # First write flattened_data array. Only write rows with data.
@@ -71,15 +76,23 @@ def _h5_write_vector_of_vectors(
     )
 
     # now offset is used to give appropriate in-file values for
-    # cumulative_length. Need to adjust it for start_row
+    # cumulative_length. Need to adjust it for start_row, if different from zero
     if start_row > 0:
         offset -= obj.cumulative_length.nda[start_row - 1]
 
     # Add offset to obj.cumulative_length itself to avoid memory allocation.
     # Then subtract it off after writing! (otherwise it will be changed
     # upon return)
-    cl_dtype = obj.cumulative_length.nda.dtype.type
-    obj.cumulative_length.nda += cl_dtype(offset)
+
+    # NOTE: this operation is not numerically safe (uint overflow in the lower
+    # part of the array), but this is not a problem because those values are
+    # not written to disk and we are going to restore the offset at the end
+    np.add(
+        obj.cumulative_length.nda,
+        offset,
+        out=obj.cumulative_length.nda,
+        casting="unsafe",
+    )
 
     _h5_write_array(
         obj.cumulative_length,
@@ -92,4 +105,10 @@ def _h5_write_vector_of_vectors(
         write_start=write_start,
         **h5py_kwargs,
     )
-    obj.cumulative_length.nda -= cl_dtype(offset)
+
+    np.subtract(
+        obj.cumulative_length.nda,
+        offset,
+        out=obj.cumulative_length.nda,
+        casting="unsafe",
+    )

{legend_pydataobj-1.6.2 → legend_pydataobj-1.7.1}/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,39 @@ 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 += ", \033[3mfilters\033[0m="
+
+                numfilters = val.id.get_create_plist().get_nfilters()
+                if numfilters == 0:
+                    toprint += "None"
+                else:
+                    toprint += "("
+                    for i in range(numfilters):
+                        thisfilter = val.id.get_create_plist().get_filter(i)[3].decode()
+                        if "lz4" in thisfilter:
+                            thisfilter = "lz4"
+                        toprint += f"{thisfilter},"
+                    toprint += ")"
+
+            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 +215,7 @@ def show(
                 header=False,
                 attrs=attrs,
                 depth=depth - 1 if depth else None,
+                detail=detail,
             )
 
         # break or move to next key
@@ -244,7 +281,7 @@ def load_nda(
         f = sto.gimme_file(ff, "r")
         for par in par_list:
             if f"{lh5_group}/{par}" not in f:
-                msg = f"'{lh5_group}/{par}' not in file {f_list[ii]}"
+                msg = f"'{lh5_group}/{par}' not in file {ff}"
                 raise RuntimeError(msg)
 
             if idx_list is None:

{legend_pydataobj-1.6.2 → legend_pydataobj-1.7.1}/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.1}/src/lgdo/types/fixedsizearray.py

@@ -50,4 +50,4 @@ class FixedSizeArray(Array):
         --------
         .LGDO.view_as
         """
-        return super.view_as(library, with_units=with_units)
+        return super().view_as(library, with_units=with_units)

{legend_pydataobj-1.6.2 → legend_pydataobj-1.7.1}/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.1}/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.1}/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.
@@ -483,7 +480,7 @@ class VectorOfVectors(LGDO):
                 lens = np.array([lens], dtype="u4")
 
             # calculate stop index in flattened_data
-            cum_lens = start + lens.cumsum()
+            cum_lens = np.add(start, lens.cumsum(), dtype=int)
 
             # fill with fast vectorized routine
             vovutils._nb_fill(vec, lens, self.flattened_data.nda[start : cum_lens[-1]])

{legend_pydataobj-1.6.2 → legend_pydataobj-1.7.1}/src/lgdo/units.py

@@ -3,4 +3,4 @@ from __future__ import annotations
 import pint
 
 default_units_registry = pint.get_application_registry()
-default_units_registry.default_format = "~P"
+default_units_registry.formatter.default_format = "~P"

{legend_pydataobj-1.6.2 → legend_pydataobj-1.7.1}/tests/compression/test_uleb128_zigzag_diff.py

@@ -68,7 +68,7 @@ def test_uleb128zzdiff_encode_decode_equality():
         pos = varlen.uleb128_encode(varlen.zigzag_encode(int(s) - last), encx)
         assert np.array_equal(sig_out[offset : offset + pos], encx[:pos])
         offset += pos
-        last = s
+        last = int(s)
 
     sig_in_dec = np.empty(100, dtype="uint32")
     siglen = np.empty(1, dtype="uint32")

{legend_pydataobj-1.6.2 → legend_pydataobj-1.7.1}/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.1}/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.1}/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)