Reject an explicit zero float width instead of the IEEE default

dali/python/nvidia/dali/experimental/dynamic/_type.py

@@ -126,8 +126,16 @@ def __init__(
         self.type_id = type_id
 
         if kind == DType.Kind.float:
-            self.exponent_bits = exponent_bits or DType._default_exponent_bits(bits, True)
-            self.significand_bits = significand_bits or DType._default_significand_bits(bits, True)
+            if exponent_bits is None:
+                exponent_bits = DType._default_exponent_bits(bits, True)
+            elif exponent_bits < 1:
+                raise ValueError(f"Invalid number of exponent bits: {exponent_bits}")
+            if significand_bits is None:
+                significand_bits = DType._default_significand_bits(bits, True)
+            elif significand_bits < 1:
+                raise ValueError(f"Invalid number of significand bits: {significand_bits}")
+            self.exponent_bits = exponent_bits
+            self.significand_bits = significand_bits
         else:
             self.exponent_bits = None
             self.significand_bits = None
@@ -278,7 +286,17 @@ def parse_internal(name: str) -> "DType":
 
         t = parse_internal(name)
         if t.type_id is None:
-            t.type_id = _type2id[t]
+            try:
+                t.type_id = _type2id[t]
+            except KeyError:
+                # __init__ caches the temporary type before this lookup. Drop that
+                # entry so a later parse does not return the rejected type. Leave a
+                # name that already pointed at a different type alone.
+                if _name2type.get(t.name) is t:
+                    del _name2type[t.name]
+                if name != t.name and _name2type.get(name) is t:
+                    del _name2type[name]
+                raise ValueError(f"{name} is not a registered type.") from None
         if t.type_id is not None:
             t = _id2type[t.type_id]  # use the same DType instance as the one registered with the id
         _name2type[name] = t

dali/test/python/experimental_mode/test_type.py

@@ -166,3 +166,22 @@ def test_type_significand_bits():
     assert ndd.float16.significand_bits == 10
     assert ndd.float32.significand_bits == 23
     assert ndd.float64.significand_bits == 52
+
+
+def test_explicit_zero_float_field_is_not_replaced_with_the_default():
+    # A written 0 used to be treated as missing, so these came back as float32 and float16.
+    cases = {
+        "f32e8m0": "Invalid number of significand bits: 0",
+        "f16e0m10": "Invalid number of exponent bits: 0",
+    }
+    for name, message in cases.items():
+        try:
+            parsed = ndd.dtype(name)
+        except ValueError as err:
+            if message not in str(err):
+                raise AssertionError(f"{name} raised {err!r}, want {message}") from err
+            continue
+        raise AssertionError(
+            f"{name} was accepted as {parsed.name} "
+            f"(exponent {parsed.exponent_bits}, significand {parsed.significand_bits})"
+        )