refactor: follow updated schema

Signed-off-by: Henry Schreiner <[email protected]>

Author: henryiii

src/boost_histogram/serialization/_storage.py

@@ -32,43 +32,37 @@ def _(
 ) -> dict[str, Any]:
     return {
         "type": "int" if np.issubdtype(data.dtype, np.integer) else "double",
-        "data": data,
+        "values": data,
     }
 
 
 @_storage_to_dict.register(storage.Weight)
 def _(_storage: storage.Weight, /, data: Any) -> dict[str, Any]:
     return {
         "type": "weighted",
-        "data": {
-            "values": data.value,
-            "variances": data.variance,
-        },
+        "values": data.value,
+        "variances": data.variance,
     }
 
 
 @_storage_to_dict.register(storage.Mean)
 def _(_storage: storage.Mean, /, data: Any) -> dict[str, Any]:
     return {
         "type": "mean",
-        "data": {
-            "counts": data.count,
-            "values": data.value,
-            "variances": data.variance,
-        },
+        "counts": data.count,
+        "values": data.value,
+        "variances": data.variance,
     }
 
 
 @_storage_to_dict.register(storage.WeightedMean)
 def _(_storage: storage.WeightedMean, /, data: Any) -> dict[str, Any]:
     return {
         "type": "weighted_mean",
-        "data": {
-            "sum_of_weights": data.sum_of_weights,
-            "sum_of_weights_squared": data.sum_of_weights_squared,
-            "values": data.value,
-            "variances": data.variance,
-        },
+        "sum_of_weights": data.sum_of_weights,
+        "sum_of_weights_squared": data.sum_of_weights_squared,
+        "values": data.value,
+        "variances": data.variance,
     }
 
 
@@ -95,20 +89,20 @@ def _data_from_dict(data: dict[str, Any], /) -> np.typing.NDArray[Any]:
     storage_type = data["type"]
 
     if storage_type in {"int", "double"}:
-        return data["data"]
+        return data["values"]
     if storage_type == "weighted":
-        return np.stack([data["data"]["values"], data["data"]["variances"]]).T
+        return np.stack([data["values"], data["variances"]]).T
     if storage_type == "mean":
         return np.stack(
-            [data["data"]["counts"], data["data"]["values"], data["data"]["variances"]],
+            [data["counts"], data["values"], data["variances"]],
         ).T
     if storage_type == "weighted_mean":
         return np.stack(
             [
-                data["data"]["sum_of_weights"],
-                data["data"]["sum_of_weights_squared"],
-                data["data"]["values"],
-                data["data"]["variances"],
+                data["sum_of_weights"],
+                data["sum_of_weights_squared"],
+                data["values"],
+                data["variances"],
             ],
         ).T
 

src/boost_histogram/serialization/hdf5.py

@@ -58,16 +58,13 @@ def write_hdf5_schema(grp: h5py.Group, /, histogram: Histogram) -> None:
     # Storage
     storage_grp = grp.create_group("storage")
     storage_type = hist_dict["storage"]["type"]
-    storage_data = hist_dict["storage"]["data"]
 
     storage_grp.attrs["type"] = storage_type
 
-    if not isinstance(storage_data, dict):
-        storage_grp.create_dataset("data", shape=storage_data.shape, data=storage_data)
-    else:
-        storage_data_grp = storage_grp.create_group("data")
-        for key, value in storage_data.items():
-            storage_data_grp.create_dataset(key, shape=value.shape, data=value)
+    for key, value in hist_dict["storage"].items():
+        if key == "type":
+            continue
+        storage_grp.create_dataset(key, shape=value.shape, data=value)
 
 
 def read_hdf5_schema(grp: h5py.Group, /) -> Histogram:
@@ -84,12 +81,8 @@ def read_hdf5_schema(grp: h5py.Group, /) -> Histogram:
     storage_grp = grp["storage"]
     assert isinstance(storage_grp, h5py.Group)
     storage: dict[str, Any] = {"type": storage_grp.attrs["type"]}
-    data_grp = storage_grp["data"]
-    if isinstance(data_grp, h5py.Dataset):
-        storage["data"] = np.array(data_grp)
-    else:
-        assert isinstance(data_grp, h5py.Group)
-        storage["data"] = {key: np.array(data_grp[key]) for key in data_grp}
+    for key in storage_grp:
+        storage[key] = np.asarray(storage_grp[key])
 
     histogram_dict = {"axes": axes, "storage": storage}
     if "metadata" in grp:

tests/test_serialization_generic.py

@@ -34,7 +34,7 @@ def test_simple_to_dict(storage_type: bh.storage.Storage, expected_type: str) ->
     assert data["axes"][0]["overflow"]
     assert not data["axes"][0]["circular"]
     assert data["storage"]["type"] == expected_type
-    assert data["storage"]["data"] == pytest.approx(np.zeros(12))
+    assert data["storage"]["values"] == pytest.approx(np.zeros(12))
 
 
 def test_weighed_to_dict() -> None:
@@ -52,8 +52,8 @@ def test_weighed_to_dict() -> None:
     assert data["axes"][0]["overflow"]
     assert not data["axes"][0]["circular"]
     assert data["storage"]["type"] == "weighted"
-    assert data["storage"]["data"]["values"] == pytest.approx(np.zeros(14))
-    assert data["storage"]["data"]["variances"] == pytest.approx(np.zeros(14))
+    assert data["storage"]["values"] == pytest.approx(np.zeros(14))
+    assert data["storage"]["variances"] == pytest.approx(np.zeros(14))
 
 
 def test_mean_to_dict() -> None:
@@ -69,9 +69,9 @@ def test_mean_to_dict() -> None:
     assert data["axes"][0]["categories"] == ["one", "two", "three"]
     assert data["axes"][0]["flow"]
     assert data["storage"]["type"] == "mean"
-    assert data["storage"]["data"]["counts"] == pytest.approx(np.zeros(4))
-    assert data["storage"]["data"]["values"] == pytest.approx(np.zeros(4))
-    assert data["storage"]["data"]["variances"] == pytest.approx(np.zeros(4))
+    assert data["storage"]["counts"] == pytest.approx(np.zeros(4))
+    assert data["storage"]["values"] == pytest.approx(np.zeros(4))
+    assert data["storage"]["variances"] == pytest.approx(np.zeros(4))
 
 
 def test_weighted_mean_to_dict() -> None:
@@ -87,16 +87,14 @@ def test_weighted_mean_to_dict() -> None:
     assert data["axes"][0]["categories"] == pytest.approx([1, 2, 3])
     assert data["axes"][0]["flow"]
     assert data["storage"]["type"] == "weighted_mean"
-    assert data["storage"]["data"]["sum_of_weights"] == pytest.approx(
+    assert data["storage"]["sum_of_weights"] == pytest.approx(
         np.array([20, 40, 60, 10])
     )
-    assert data["storage"]["data"]["sum_of_weights_squared"] == pytest.approx(
+    assert data["storage"]["sum_of_weights_squared"] == pytest.approx(
         np.array([200, 800, 1800, 50])
     )
-    assert data["storage"]["data"]["values"] == pytest.approx(
-        np.array([100, 200, 300, 1])
-    )
-    assert data["storage"]["data"]["variances"] == pytest.approx(np.zeros(4))
+    assert data["storage"]["values"] == pytest.approx(np.array([100, 200, 300, 1]))
+    assert data["storage"]["variances"] == pytest.approx(np.zeros(4))
 
 
 def test_transform_log_axis_to_dict() -> None: