#156 Rename enum and related codes (FType → Role)

Author: astropenguin

tests/test_typing.py

@@ -14,12 +14,12 @@
     Attr,
     Coord,
     Data,
-    FType,
     Name,
+    Role,
     get_dims,
     get_dtype,
-    get_ftype,
     get_name,
+    get_role,
 )
 
 
@@ -54,24 +54,6 @@
     (Union[Ann[Data[Any, float], "data"], Ann[Any, "any"]], np.dtype("f8")),
 ]
 
-testdata_ftype = [
-    (Attr[Any], FType.ATTR),
-    (Data[Any, Any], FType.DATA),
-    (Coord[Any, Any], FType.COORD),
-    (Name[Any], FType.NAME),
-    (Any, FType.OTHER),
-    (Ann[Attr[Any], "attr"], FType.ATTR),
-    (Ann[Data[Any, Any], "data"], FType.DATA),
-    (Ann[Coord[Any, Any], "coord"], FType.COORD),
-    (Ann[Name[Any], "name"], FType.NAME),
-    (Ann[Any, "other"], FType.OTHER),
-    (Union[Ann[Attr[Any], "attr"], Ann[Any, "any"]], FType.ATTR),
-    (Union[Ann[Data[Any, Any], "data"], Ann[Any, "any"]], FType.DATA),
-    (Union[Ann[Coord[Any, Any], "coord"], Ann[Any, "any"]], FType.COORD),
-    (Union[Ann[Name[Any], "name"], Ann[Any, "any"]], FType.NAME),
-    (Union[Ann[Any, "other"], Ann[Any, "any"]], FType.OTHER),
-]
-
 testdata_name = [
     (Attr[Any], None),
     (Data[Any, Any], None),
@@ -90,6 +72,24 @@
     (Union[Ann[Any, "other"], Ann[Any, "any"]], None),
 ]
 
+testdata_role = [
+    (Attr[Any], Role.ATTR),
+    (Data[Any, Any], Role.DATA),
+    (Coord[Any, Any], Role.COORD),
+    (Name[Any], Role.NAME),
+    (Any, Role.OTHER),
+    (Ann[Attr[Any], "attr"], Role.ATTR),
+    (Ann[Data[Any, Any], "data"], Role.DATA),
+    (Ann[Coord[Any, Any], "coord"], Role.COORD),
+    (Ann[Name[Any], "name"], Role.NAME),
+    (Ann[Any, "other"], Role.OTHER),
+    (Union[Ann[Attr[Any], "attr"], Ann[Any, "any"]], Role.ATTR),
+    (Union[Ann[Data[Any, Any], "data"], Ann[Any, "any"]], Role.DATA),
+    (Union[Ann[Coord[Any, Any], "coord"], Ann[Any, "any"]], Role.COORD),
+    (Union[Ann[Name[Any], "name"], Ann[Any, "any"]], Role.NAME),
+    (Union[Ann[Any, "other"], Ann[Any, "any"]], Role.OTHER),
+]
+
 
 # test functions
 @mark.parametrize("tp, dims", testdata_dims)
@@ -102,11 +102,11 @@ def test_get_dtype(tp: Any, dtype: Any) -> None:
     assert get_dtype(tp) == dtype
 
 
-@mark.parametrize("tp, ftype", testdata_ftype)
-def test_get_ftype(tp: Any, ftype: Any) -> None:
-    assert get_ftype(tp) == ftype
-
-
 @mark.parametrize("tp, name", testdata_name)
 def test_get_name(tp: Any, name: Any) -> None:
     assert get_name(tp) == name
+
+
+@mark.parametrize("tp, role", testdata_role)
+def test_get_role(tp: Any, role: Any) -> None:
+    assert get_role(tp) == role

xarray_dataclasses/datamodel.py

@@ -17,16 +17,16 @@
 from .typing import (
     AnyDType,
     AnyField,
-    DataClass,
     AnyXarray,
+    DataClass,
     Dims,
-    FType,
+    Role,
     get_annotated,
     get_dataclass,
     get_dims,
     get_dtype,
-    get_ftype,
     get_name,
+    get_role,
 )
 
 
@@ -209,29 +209,29 @@ def eval_dataclass(dataclass: AnyDataClass[PInit]) -> None:
 
 def get_entry(field: AnyField, value: Any) -> Optional[AnyEntry]:
     """Create an entry from a field and its value."""
-    ftype = get_ftype(field.type)
+    role = get_role(field.type)
     name = get_name(field.type, field.name)
 
-    if ftype is FType.ATTR or ftype is FType.NAME:
+    if role is Role.ATTR or role is Role.NAME:
         return AttrEntry(
             name=name,
-            tag=ftype.value,
+            tag=role.value,
             value=value,
             type=get_annotated(field.type),
         )
 
-    if ftype is FType.COORD or ftype is FType.DATA:
+    if role is Role.COORD or role is Role.DATA:
         try:
             return DataEntry(
                 name=name,
-                tag=ftype.value,
+                tag=role.value,
                 base=get_dataclass(field.type),
                 value=value,
             )
         except TypeError:
             return DataEntry(
                 name=name,
-                tag=ftype.value,
+                tag=role.value,
                 dims=get_dims(field.type),
                 dtype=get_dtype(field.type),
                 value=value,

xarray_dataclasses/typing.py

@@ -87,7 +87,7 @@ class Labeled(Generic[TDims]):
 
 
 # type hints (public)
-class FType(Enum):
+class Role(Enum):
     """Annotations for typing dataclass fields."""
 
     ATTR = "attr"
@@ -107,14 +107,14 @@ class FType(Enum):
 
     @classmethod
     def annotates(cls, tp: Any) -> bool:
-        """Check if any ftype annotates a type hint."""
+        """Check if any role annotates a type hint."""
         if get_origin(tp) is not Annotated:
             return False
 
         return any(isinstance(arg, cls) for arg in get_args(tp))
 
 
-Attr = Annotated[T, FType.ATTR]
+Attr = Annotated[T, Role.ATTR]
 """Type hint for attribute fields (``Attr[T]``).
 
 Example:
@@ -137,7 +137,7 @@ class Image(AsDataArray):
 
 """
 
-Coord = Annotated[Union[Labeled[TDims], Collection[TDType], TDType], FType.COORD]
+Coord = Annotated[Union[Labeled[TDims], Collection[TDType], TDType], Role.COORD]
 """Type hint for coordinate fields (``Coord[TDims, TDType]``).
 
 Example:
@@ -156,7 +156,7 @@ class Image(AsDataArray):
 
 """
 
-Coordof = Annotated[Union[TDataClass, Any], FType.COORD]
+Coordof = Annotated[Union[TDataClass, Any], Role.COORD]
 """Type hint for coordinate fields (``Coordof[TDataClass]``).
 
 Unlike ``Coord``, it specifies a dataclass that defines a DataArray class.
@@ -188,7 +188,7 @@ class Image(AsDataArray):
 
 """
 
-Data = Annotated[Union[Labeled[TDims], Collection[TDType], TDType], FType.DATA]
+Data = Annotated[Union[Labeled[TDims], Collection[TDType], TDType], Role.DATA]
 """Type hint for data fields (``Coordof[TDims, TDType]``).
 
 Example:
@@ -209,7 +209,7 @@ class ColorImage(AsDataset):
 
 """
 
-Dataof = Annotated[Union[TDataClass, Any], FType.DATA]
+Dataof = Annotated[Union[TDataClass, Any], Role.DATA]
 """Type hint for data fields (``Coordof[TDataClass]``).
 
 Unlike ``Data``, it specifies a dataclass that defines a DataArray class.
@@ -236,7 +236,7 @@ class ColorImage(AsDataset):
 
 """
 
-Name = Annotated[THashable, FType.NAME]
+Name = Annotated[THashable, Role.NAME]
 """Type hint for name fields (``Name[THashable]``).
 
 Example:
@@ -272,19 +272,19 @@ def find_annotated(tp: Any) -> Iterable[Any]:
 
 
 def get_annotated(tp: Any) -> Any:
-    """Extract the first ftype-annotated type."""
-    for annotated in filter(FType.annotates, find_annotated(tp)):
+    """Extract the first role-annotated type."""
+    for annotated in filter(Role.annotates, find_annotated(tp)):
         return deannotate(annotated)
 
-    raise TypeError("Could not find any ftype-annotated type.")
+    raise TypeError("Could not find any role-annotated type.")
 
 
 def get_annotations(tp: Any) -> Tuple[Any, ...]:
-    """Extract annotations of the first ftype-annotated type."""
-    for annotated in filter(FType.annotates, find_annotated(tp)):
+    """Extract annotations of the first role-annotated type."""
+    for annotated in filter(Role.annotates, find_annotated(tp)):
         return get_args(annotated)[1:]
 
-    raise TypeError("Could not find any ftype-annotated type.")
+    raise TypeError("Could not find any role-annotated type.")
 
 
 def get_dataclass(tp: Any) -> Type[DataClass[Any]]:
@@ -341,14 +341,6 @@ def get_dtype(tp: Any) -> Optional[AnyDType]:
     return np.dtype(dtype)
 
 
-def get_ftype(tp: Any, default: FType = FType.OTHER) -> FType:
-    """Extract an ftype if found or return given default."""
-    try:
-        return get_annotations(tp)[0]
-    except TypeError:
-        return default
-
-
 def get_name(tp: Any, default: Hashable = None) -> Hashable:
     """Extract a name if found or return given default."""
     try:
@@ -361,3 +353,11 @@ def get_name(tp: Any, default: Hashable = None) -> Hashable:
             return annotation
 
     return default
+
+
+def get_role(tp: Any, default: Role = Role.OTHER) -> Role:
+    """Extract a role if found or return given default."""
+    try:
+        return get_annotations(tp)[0]
+    except TypeError:
+        return default