fix: check for all or none value fields

Signed-off-by: Henry Schreiner <henryfs@princeton.edu>

Author: henryiii

src/boost_histogram/serialization/__init__.py

@@ -23,6 +23,44 @@ def __dir__() -> list[str]:
     return __all__
 
 
+def _storage_has_data_keys(storage_data: dict[str, Any], storage_type: str) -> bool:
+    """
+    Check if storage data dict has the required keys for the given storage type.
+
+    Returns True if all required data keys are present, False if it's structure-only.
+    Raises ValueError if required keys are missing (malformed/partial data).
+    """
+    match storage_type:
+        case "int" | "double":
+            required_keys = {"values"}
+        case "weighted":
+            required_keys = {"values", "variances"}
+        case "mean":
+            required_keys = {"counts", "values", "variances"}
+        case "weighted_mean":
+            required_keys = {
+                "sum_of_weights",
+                "sum_of_weights_squared",
+                "values",
+                "variances",
+            }
+        case _:
+            msg = f"Unknown storage type: {storage_type}"
+            raise ValueError(msg)
+
+    present_keys = required_keys & set(storage_data.keys())
+
+    if not present_keys:
+        return False
+
+    if present_keys != required_keys:
+        missing = required_keys - present_keys
+        msg = f"{storage_type.capitalize()} storage missing required keys: {missing}"
+        raise ValueError(msg)
+
+    return True
+
+
 def to_uhi(
     h: histogram.Histogram[Any], /, *, keep_storage: bool = True
 ) -> dict[str, Any]:
@@ -61,7 +99,11 @@ def from_uhi(data: dict[str, Any], /) -> histogram.Histogram[Any]:
     h.__dict__ = data.get("metadata", {})
 
     # Check if storage has data (if not, it's a structure-only histogram)
-    if "values" not in storage_data:
+    # Validate required keys per storage type before deciding to skip data loading
+    storage_type = storage_data["type"]
+    has_data_keys = _storage_has_data_keys(storage_data, storage_type)
+
+    if not has_data_keys:
         return h
 
     raw_data = _data_from_dict(storage_data)

tests/test_serialization_uhi.py

@@ -502,3 +502,109 @@ def test_round_trip_3d_histogram_json_constructor() -> None:
 
     assert h.ndim == h2.ndim
     assert h == h2
+
+
+def test_from_uhi_malformed_weight_storage() -> None:
+    """Test that malformed Weight storage ( missing required keys) raises ValueError."""
+    data = {
+        "uhi_schema": 1,
+        "axes": [
+            {
+                "type": "regular",
+                "lower": 0,
+                "upper": 10,
+                "bins": 5,
+                "underflow": True,
+                "overflow": True,
+                "circular": False,
+            }
+        ],
+        "storage": {
+            "type": "weighted",
+            "values": [1, 2, 3, 4, 5],
+        },
+        "metadata": {},
+    }
+
+    with pytest.raises(ValueError, match="Weighted storage missing required keys"):
+        from_uhi(data)
+
+
+def test_from_uhi_malformed_mean_storage() -> None:
+    """Test that malformed Mean storage (missing required keys) raises ValueError."""
+    data = {
+        "uhi_schema": 1,
+        "axes": [
+            {
+                "type": "regular",
+                "lower": 0,
+                "upper": 10,
+                "bins": 5,
+                "underflow": True,
+                "overflow": True,
+                "circular": False,
+            }
+        ],
+        "storage": {
+            "type": "mean",
+            "counts": [1, 2, 3, 4, 5],
+            "values": [1, 2, 3, 4, 5],
+        },
+        "metadata": {},
+    }
+
+    with pytest.raises(ValueError, match="Mean storage missing required keys"):
+        from_uhi(data)
+
+
+def test_from_uhi_malformed_weighted_mean_storage() -> None:
+    """Test that malformed WeightedMean storage (missing required keys) raises ValueError."""
+    data = {
+        "uhi_schema": 1,
+        "axes": [
+            {
+                "type": "regular",
+                "lower": 0,
+                "upper": 10,
+                "bins": 5,
+                "underflow": True,
+                "overflow": True,
+                "circular": False,
+            }
+        ],
+        "storage": {
+            "type": "weighted_mean",
+            "sum_of_weights": [1, 2, 3, 4, 5],
+            "values": [1, 2, 3, 4, 5],
+        },
+        "metadata": {},
+    }
+
+    with pytest.raises(ValueError, match="Weighted_mean storage missing required keys"):
+        from_uhi(data)
+
+
+def test_from_uhi_structure_only_no_error() -> None:
+    """Test that structure-only (no data keys) histograms load correctly."""
+    data = {
+        "uhi_schema": 1,
+        "axes": [
+            {
+                "type": "regular",
+                "lower": 0,
+                "upper": 10,
+                "bins": 5,
+                "underflow": True,
+                "overflow": True,
+                "circular": False,
+            }
+        ],
+        "storage": {
+            "type": "double",
+        },
+        "metadata": {},
+    }
+
+    h = from_uhi(data)
+    assert h.storage_type is bh.storage.Double
+    assert np.asarray(h) == pytest.approx(np.zeros(5))