fix: recognize PEP 604 union syntax in _attribute_is_optional

Closes #293. `_attribute_is_optional` only checked
`typing.get_origin(attribute.type) is Union`, so Metric and attr_from
classes defined with PEP 604 annotations (`T | None`) treated optional
fields as required. Mirror the dual-origin check already used by
`_is_optional` in fgpyo/util/types.py.

Also folds in the deferred #286 migrations in test_metric.py (7 sites)
and test_inspect.py (3 sites), which exercise this code path. A new
LegacyOptionalName attr class and two tests keep coverage of the
legacy `Union` / `Optional` syntax branch.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: msto

fgpyo/util/inspect.py

@@ -491,7 +491,8 @@ def attr_from(
 
 def _attribute_is_optional(attribute: FieldType) -> bool:
     """Returns True if the attribute is optional, False otherwise."""
-    return typing.get_origin(attribute.type) is Union and isinstance(
+    origin = typing.get_origin(attribute.type)
+    return (origin is Union or origin is python_types.UnionType) and isinstance(
         None, typing.get_args(attribute.type)
     )
 

tests/fgpyo/util/test_inspect.py

@@ -4,6 +4,7 @@
 from typing import Optional
 from typing import Set
 from typing import Tuple
+from typing import Union
 
 import attr
 import pytest
@@ -28,9 +29,23 @@ class Name:
     required: str
     custom_parser: str
     converted: int = attr.field(converter=int)
+    optional_no_default: str | None
+    optional_with_default_none: str | None = None
+    optional_with_default_some: str | None = "foo"
+
+
+@attr.s(auto_attribs=True, frozen=True)
+class LegacyOptionalName:
+    """
+    Test attr class using legacy `Optional[T]` / `Union[T, None]` syntax.
+
+    Kept to ensure `_attribute_is_optional` continues to recognize the
+    `typing.Union` origin alongside `types.UnionType` (PEP 604).
+    """
+
+    required: str
     optional_no_default: Optional[str]
-    optional_with_default_none: Optional[str] = None
-    optional_with_default_some: Optional[str] = "foo"
+    union_with_none: Union[str, None] = None
 
 
 def test_attr_from() -> None:
@@ -57,6 +72,13 @@ def test_attribute_is_optional() -> None:
     assert _attribute_is_optional(fields_dict["optional_with_default_some"])
 
 
+def test_attribute_is_optional_legacy_syntax() -> None:
+    fields_dict = attr.fields_dict(LegacyOptionalName)
+    assert not _attribute_is_optional(fields_dict["required"])
+    assert _attribute_is_optional(fields_dict["optional_no_default"])
+    assert _attribute_is_optional(fields_dict["union_with_none"])
+
+
 def test_attribute_has_default() -> None:
     fields_dict = attr.fields_dict(Name)
     assert not _attribute_has_default(fields_dict["required"])
@@ -67,6 +89,13 @@ def test_attribute_has_default() -> None:
     assert _attribute_has_default(fields_dict["optional_with_default_some"])
 
 
+def test_attribute_has_default_legacy_syntax() -> None:
+    fields_dict = attr.fields_dict(LegacyOptionalName)
+    assert not _attribute_has_default(fields_dict["required"])
+    assert _attribute_has_default(fields_dict["optional_no_default"])
+    assert _attribute_has_default(fields_dict["union_with_none"])
+
+
 class Foo:
     """Test class used as a field type."""
 

tests/fgpyo/util/test_metric.py

@@ -12,7 +12,6 @@
 from typing import Callable
 from typing import Dict
 from typing import List
-from typing import Optional
 from typing import Set
 from typing import Tuple
 from typing import Type
@@ -108,8 +107,8 @@ class DummyMetric(Metric["DummyMetric"]):
 
         @make_dataclass(use_attr=use_attr)
         class Person(Metric["Person"]):
-            name: Optional[str]
-            age: Optional[int]
+            name: str | None
+            age: int | None
 
         @make_dataclass(use_attr=use_attr)
         class Name:
@@ -145,7 +144,7 @@ def format_value(cls, value: Any) -> str:
         @make_dataclass(use_attr=use_attr)
         class PersonMaybeAge(Metric["PersonMaybeAge"]):
             name: str
-            age: Optional[int]
+            age: int | None
 
         @make_dataclass(use_attr=use_attr)
         class PersonDefault(Metric["PersonDefault"]):
@@ -154,13 +153,13 @@ class PersonDefault(Metric["PersonDefault"]):
 
         @make_dataclass(use_attr=use_attr)
         class PersonAgeFloat(Metric["PersonAgeFloat"]):
-            name: Optional[str]
-            age: Optional[float]
+            name: str | None
+            age: float | None
 
         @make_dataclass(use_attr=use_attr)
         class ListPerson(Metric["ListPerson"]):
-            name: List[Optional[str]]
-            age: List[Optional[int]]
+            name: List[str | None]
+            age: List[int | None]
 
         self.DummyMetric = DummyMetric
         self.Person = Person