legend-pydataobj 1.11.7__tar.gz → 1.11.10__tar.gz

{legend_pydataobj-1.11.7 → legend_pydataobj-1.11.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: legend_pydataobj
-Version: 1.11.7
+Version: 1.11.10
 Summary: LEGEND Python Data Objects
 Author: The LEGEND Collaboration
 Maintainer: The LEGEND Collaboration

{legend_pydataobj-1.11.7 → legend_pydataobj-1.11.10}/src/legend_pydataobj.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: legend_pydataobj
-Version: 1.11.7
+Version: 1.11.10
 Summary: LEGEND Python Data Objects
 Author: The LEGEND Collaboration
 Maintainer: The LEGEND Collaboration

{legend_pydataobj-1.11.7 → legend_pydataobj-1.11.10}/src/lgdo/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.11.7'
-__version_tuple__ = version_tuple = (1, 11, 7)
+__version__ = version = '1.11.10'
+__version_tuple__ = version_tuple = (1, 11, 10)

{legend_pydataobj-1.11.7 → legend_pydataobj-1.11.10}/src/lgdo/lh5/_serializers/write/composite.py

@@ -186,19 +186,31 @@ def _h5_write_struct(
     write_start=0,
     **h5py_kwargs,
 ):
+    # this works for structs and derived (tables)
     assert isinstance(obj, types.Struct)
 
     # In order to append a column, we need to update the
-    # `table{old_fields}` value in `group.attrs['datatype"]` to include
-    # the new fields.  One way to do this is to override
-    # `obj.attrs["datatype"]` to include old and new fields. Then we
-    # can write the fields to the table as normal.
+    # `struct/table{old_fields}` value in `group.attrs['datatype"]` to include
+    # the new fields. One way to do this is to override `obj.attrs["datatype"]`
+    # to include old and new fields. Then we can write the fields to the
+    # struct/table as normal.
     if wo_mode == "ac":
+        if name not in group:
+            msg = "Cannot append column to non-existing struct on disk"
+            raise LH5EncodeError(msg, lh5_file, group, name)
+
         old_group = utils.get_h5_group(name, group)
+        if "datatype" not in old_group.attrs:
+            msg = "Cannot append column to an existing  non-LGDO object on disk"
+            raise LH5EncodeError(msg, lh5_file, group, name)
+
         lgdotype = datatype.datatype(old_group.attrs["datatype"])
         fields = datatype.get_struct_fields(old_group.attrs["datatype"])
-        if not issubclass(lgdotype, types.Struct):
-            msg = f"Trying to append columns to an object of type {lgdotype.__name__}"
+        if lgdotype is not type(obj):
+            msg = (
+                "Trying to append columns to an object of different "
+                f"type {lgdotype.__name__}!={type(obj)}"
+            )
             raise LH5EncodeError(msg, lh5_file, group, name)
 
         # If the mode is `append_column`, make sure we aren't appending
@@ -211,8 +223,12 @@ def _h5_write_struct(
                 "column(s) to a table with the same field(s)"
             )
             raise LH5EncodeError(msg, lh5_file, group, name)
+
         # It doesn't matter what key we access, as all fields in the old table have the same size
-        if old_group[next(iter(old_group.keys()))].size != obj.size:
+        if (
+            isinstance(obj, types.Table)
+            and old_group[next(iter(old_group.keys()))].size != obj.size
+        ):
             msg = (
                 f"Table sizes don't match. Trying to append column of size {obj.size} "
                 f"to a table of size {old_group[next(iter(old_group.keys()))].size}."
@@ -222,16 +238,25 @@ def _h5_write_struct(
         # Now we can append the obj.keys() to the old fields, and then update obj.attrs.
         fields.extend(list(obj.keys()))
         obj.attrs.pop("datatype")
-        obj.attrs["datatype"] = "table" + "{" + ",".join(fields) + "}"
+
+        obj.attrs["datatype"] = obj.datatype_name() + "{" + ",".join(fields) + "}"
+
+        # propagating wo_mode="ac" to nested LGDOs does not make any sense
+        wo_mode = "append"
+
+        # overwrite attributes of the existing struct
+        attrs_overwrite = True
+    else:
+        attrs_overwrite = wo_mode == "o"
 
     group = utils.get_h5_group(
         name,
         group,
         grp_attrs=obj.attrs,
-        overwrite=(wo_mode in ["o", "ac"]),
+        overwrite=attrs_overwrite,
     )
     # If the mode is overwrite, then we need to peek into the file's
-    # table's existing fields.  If we are writing a new table to the
+    # table's existing fields. If we are writing a new table to the
     # group that does not contain an old field, we should delete that
     # old field from the file
     if wo_mode == "o":
@@ -260,11 +285,9 @@ def _h5_write_struct(
         else:
             obj_fld = obj[field]
 
-        # Convert keys to string for dataset names
-        f = str(field)
         _h5_write_lgdo(
             obj_fld,
-            f,
+            str(field),
             lh5_file,
             group=group,
             start_row=start_row,

{legend_pydataobj-1.11.7 → legend_pydataobj-1.11.10}/src/lgdo/lh5/core.py

@@ -273,11 +273,13 @@ def write(
           end of array is the same as ``append``.
         - ``overwrite_file`` or ``of``: delete file if present prior to
           writing to it. `write_start` should be 0 (its ignored).
-        - ``append_column`` or ``ac``: append columns from an
-          :class:`~.lgdo.table.Table` `obj` only if there is an existing
-          :class:`~.lgdo.table.Table` in the `lh5_file` with the same
-          `name` and :class:`~.lgdo.table.Table.size`. If the sizes don't
-          match, or if there are matching fields, it errors out.
+        - ``append_column`` or ``ac``: append fields/columns from an
+          :class:`~.lgdo.struct.Struct` `obj` (and derived types such as
+          :class:`~.lgdo.table.Table`) only if there is an existing
+          :class:`~.lgdo.struct.Struct` in the `lh5_file` with the same `name`.
+          If there are matching fields, it errors out. If appending to a
+          ``Table`` and the size of the new column is different from the size
+          of the existing table, it errors out.
     write_start
         row in the output file (if already existing) to start overwriting
         from.

{legend_pydataobj-1.11.7 → legend_pydataobj-1.11.10}/tests/lh5/test_lh5_write.py

@@ -537,3 +537,56 @@ def test_write_histogram_variable(caplog, tmptestdir):
     assert h3.attrs["testattr"] == "test"
     assert h3["weights"].attrs["weightattr"] == "testweight"
     assert h3.binning[0].attrs["binningattr"] == "testbinning"
+
+
+def test_write_append_struct(tmptestdir):
+    outfile = f"{tmptestdir}/test-write-append-struct.lh5"
+    st = types.Struct({"arr1": types.Table({"a": types.Array([1, 2, 3])})})
+    lh5.write(st, "struct", outfile, wo_mode="of")
+    st2 = types.Struct({"arr2": types.Table({"a": types.Array([1, 2, 3])})})
+    lh5.write(st2, "struct", outfile, wo_mode="ac")
+
+    result = lh5.read("struct", outfile)
+    assert list(result.keys()) == ["arr1", "arr2"]
+    assert len(result.arr1) == len(st.arr1)
+    assert len(result.arr2) == len(st2.arr2)
+
+    # test error when appending existing field
+    with pytest.raises(lh5.exceptions.LH5EncodeError):
+        lh5.write(
+            types.Struct({"arr2": types.Array([4, 5, 6])}),
+            "struct",
+            outfile,
+            wo_mode="ac",
+        )
+
+    # error if appending to object of different type
+    with pytest.raises(lh5.exceptions.LH5EncodeError):
+        lh5.write(
+            types.Struct({"arr2": types.Array([4, 5, 6])}),
+            "struct",
+            outfile,
+            wo_mode="ac",
+        )
+
+    lh5.write(
+        types.Table({"arr1": types.Array([1, 2, 3])}), "struct", outfile, wo_mode="of"
+    )
+
+    # error if appending to object of different type
+    with pytest.raises(lh5.exceptions.LH5EncodeError):
+        lh5.write(
+            types.Table({"arr2": types.Array([4, 5, 6, 7])}),
+            "struct",
+            outfile,
+            wo_mode="ac",
+        )
+
+    # append to empty struct
+    lh5.write(types.Struct({}), "struct", outfile, wo_mode="of")
+    st2 = types.Struct({"arr2": types.Table({"a": types.Array([1, 2, 3])})})
+    lh5.write(st2, "struct", outfile, wo_mode="ac")
+
+    result = lh5.read("struct", outfile)
+    assert list(result.keys()) == ["arr2"]
+    assert len(result.arr2) == len(st2.arr2)