fix: typeguard

Author: msto

fgpyo/util/inspect.py

@@ -71,7 +71,6 @@ def get_attr_fields_dict(cls: type) -> Dict[str, dataclasses.Field]:  # type: ig
 if TYPE_CHECKING:  # pragma: no cover
     from _typeshed import DataclassInstance
 else:
-
     # https://github.com/python/typeshed/blob/727f3c4320d2af3af2f16695e24dd78e79b7c070/stdlib/_typeshed/__init__.pyi#L348
     # TODO: update the hint to `Field[Any]` when we drop support for 3.8
     class DataclassInstance(Protocol):
@@ -81,7 +80,6 @@ class DataclassInstance(Protocol):
 if TYPE_CHECKING and _use_attr:  # pragma: no cover
     from attr import AttrsInstance
 else:
-
     # https://github.com/python-attrs/attrs/blob/f7f317ae4c3790f23ae027db626593d50e8a4e88/src/attr/_typing_compat.pyi#L9
     class AttrsInstance(Protocol):  # type: ignore[no-redef]
         __attrs_attrs__: ClassVar[Any]

fgpyo/util/metric.py

@@ -119,13 +119,15 @@
 import dataclasses
 from abc import ABC
 from enum import Enum
+from inspect import isclass
 from pathlib import Path
 from typing import Any
 from typing import Callable
 from typing import Dict
 from typing import Generic
 from typing import Iterator
 from typing import List
+from typing import TypeGuard
 from typing import TypeVar
 
 import attr
@@ -339,12 +341,53 @@ def fast_concat(*inputs: Path, output: Path) -> None:
             )
 
 
+def is_dataclass_instance(metric: Metric) -> TypeGuard[inspect.DataclassInstance]:
+    """
+    Test if the given metric is a dataclass instance.
+
+    NB: `dataclasses.is_dataclass` returns True for both dataclass instances and class objects, and
+    we need to override the built-in function's `TypeGuard`.
+
+    Args:
+        metric: An instance of a Metric.
+
+    Returns:
+        True if the given metric is an instance of a dataclass-decorated Metric.
+        False otherwise.
+    """
+    return not isclass(metric) and dataclasses.is_dataclass(metric)
+
+
+def is_attrs_instance(metric: Metric) -> TypeGuard[inspect.AttrsInstance]:
+    """
+    Test if the given metric is an attr.s instance.
+
+    NB: `attr.has` does not provide a type guard, which we need to use other `attr` methods such as
+    `asdict()`, so we implement one here.
+
+    Args:
+        metric: An instance of a Metric.
+
+    Returns:
+        True if the given metric is an instance of an attr.s-decorated Metric.
+        False otherwise.
+    """
+    return not isclass(metric) and attr.has(metric.__class__)
+
+
 def asdict(metric: Metric) -> dict[str, Any]:
-    """Convert a Metric instance to a dictionary."""
+    """
+    Convert a Metric instance to a dictionary.
 
-    if dataclasses.is_dataclass(metric):
+    Args:
+        metric: An instance of a Metric.
+
+    Returns:
+        A dictionary representation of the given metric.
+    """
+    if is_dataclass_instance(metric):
         return dataclasses.asdict(metric)
-    elif attr.has(metric):
+    elif is_attrs_instance(metric):
         return attr.asdict(metric)
     else:
         assert False, "Unreachable"

fgpyo/util/tests/test_metric.py

@@ -29,6 +29,9 @@
 from fgpyo.util.inspect import is_attr_class
 from fgpyo.util.inspect import is_dataclasses_class
 from fgpyo.util.metric import Metric
+from fgpyo.util.metric import asdict
+from fgpyo.util.metric import is_attrs_instance
+from fgpyo.util.metric import is_dataclass_instance
 
 
 class EnumTest(enum.Enum):
@@ -519,3 +522,24 @@ def test_metric_columns_out_of_order(tmp_path: Path, data_and_classes: DataBuild
     names = list(NameMetric.read(path=path))
     assert len(names) == 1
     assert names[0] == name
+
+
+def test_is_dataclass_instance() -> None:
+    """Test that is_dataclass_instance works as expected."""
+
+    assert is_dataclass_instance(dataclasses_data_and_classes.Person(name="name", age=42))
+    assert not is_dataclass_instance(attr_data_and_classes.Person(name="name", age=42))
+
+
+def test_is_attrs_instance() -> None:
+    """Test that is_attrs_instance works as expected."""
+
+    assert not is_attrs_instance(dataclasses_data_and_classes.Person(name="name", age=42))
+    assert is_attrs_instance(attr_data_and_classes.Person(name="name", age=42))
+
+
+@pytest.mark.parametrize("data_and_classes", (attr_data_and_classes, dataclasses_data_and_classes))
+def test_asdict(data_and_classes: DataBuilder) -> None:
+    """Test that is_dataclass_instance works as expected."""
+
+    assert asdict(data_and_classes.Person(name="name", age=42)) == {"name": "name", "age": 42}