#137 Add new DataModel (no runtime codes)

Author: astropenguin

xarray_dataclasses/datamodel.py

@@ -2,168 +2,136 @@
 
 
 # standard library
-from dataclasses import Field, dataclass, field, is_dataclass
-from typing import Any, Dict, Hashable, Optional, Type, Union, cast
+from dataclasses import dataclass, field, is_dataclass
+from typing import Any, Dict, Hashable, List, Optional, Tuple, Type, Union, cast
 
 
 # dependencies
 import numpy as np
 import xarray as xr
-from typing_extensions import ParamSpec, TypedDict, get_args, get_type_hints
+from typing_extensions import Literal, ParamSpec, get_type_hints
 
 
 # submodules
-from .typing import (
-    ArrayLike,
-    DataClass,
-    DataType,
-    Dims,
-    Dtype,
-    FieldType,
-    get_dims,
-    get_dtype,
-    get_inner,
-    unannotate,
-)
+from .typing import ArrayLike, DataClass, DataType, Dims, Dtype
 
 
 # type hints
 P = ParamSpec("P")
 AnyDataClass = Union[Type[DataClass[P]], DataClass[P]]
-DimsDtype = TypedDict("DimsDtype", dims=Dims, dtype=Dtype)
+AnyEntry = Union["AttrEntry", "DataEntry"]
 
 
-# field models
-@dataclass(frozen=True)
-class Data:
-    """Field model for data-related fields."""
+# constants
+class MissingType:
+    """Singleton that indicates missing data."""
 
-    name: Hashable
-    """Name of the field."""
+    _instance = None
 
-    value: Any
-    """Value assigned to the field."""
+    def __new__(cls) -> "MissingType":
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
 
-    type: DimsDtype
-    """Type (dims and dtype) of the field."""
+        return cls._instance
 
-    factory: Any = None
-    """Factory dataclass to create a DataArray object."""
+    def __repr__(self) -> str:
+        return "<MISSING>"
 
-    def __call__(self, reference: Optional[DataType] = None) -> xr.DataArray:
-        """Create a DataArray object from the value and a reference."""
-        from .dataarray import asdataarray
-
-        if self.factory is None:
-            return typedarray(
-                self.value,
-                self.type["dims"],
-                self.type["dtype"],
-                reference,
-            )
-
-        if is_dataclass(self.value):
-            return asdataarray(self.value, reference)
-        else:
-            return asdataarray(self.factory(self.value), reference)
 
-    @classmethod
-    def from_field(cls, field: Field[Any], value: Any, of: bool) -> "Data":
-        """Create a field model from a dataclass field and a value."""
-        hint = unannotate(field.type)
+MISSING = MissingType()
+
+
+# runtime classes
+@dataclass(frozen=True)
+class AttrEntry:
+    """Entry of an attribute (i.e. metadata)."""
+
+    name: Hashable
+    """Name that the attribute is accessed by."""
 
-        if not of:
-            type: DimsDtype = {
-                "dims": get_dims(get_args(hint)[0]),
-                "dtype": get_dtype(get_args(hint)[0]),
-            }
-            return cls(field.name, value, type)
+    tag: Literal["attr", "name"]
+    """Function of the attribute (either attr or name)."""
 
-        dataclass = get_inner(hint, 0)
-        model = DataModel.from_dataclass(dataclass)
-        data_item = next(iter(model.data.values()))
+    type: Any = None
+    """Type or type hint of the attribute."""
 
-        if not model.name:
-            return cls(field.name, value, data_item.type, dataclass)
-        else:
-            name_item = next(iter(model.name.values()))
-            return cls(name_item.value, value, data_item.type, dataclass)
+    value: Any = MISSING
+    """Actual value of the attribute."""
+
+    cast: bool = False
+    """Whether the value is cast to the type."""
+
+    def __call__(self) -> Any:
+        """Create an object according to the entry."""
+        ...
 
 
 @dataclass(frozen=True)
-class General:
-    """Field model for general fields."""
+class DataEntry:
+    """Entry of a data variable."""
 
     name: Hashable
-    """Name of the field."""
+    """Name that the attribute is accessed by."""
 
-    value: Any
-    """Value assigned to the field."""
+    tag: Literal["coord", "data"]
+    """Function of the data (either coord or data)."""
 
-    type: str
-    """Type of the field."""
+    dims: Dims = cast(Dims, None)
+    """Dimensions of the DataArray that the data is cast to."""
 
-    factory: Optional[Type[Any]] = None
-    """Factory function to create an object."""
+    dtype: Dtype = cast(Dtype, None)
+    """Data type of the DataArray that the data is cast to."""
 
-    def __call__(self) -> Any:
-        """Create an object from the value."""
-        if self.factory is None:
-            return self.value
-        else:
-            return self.factory(self.value)
+    base: Optional[Type[Any]] = None
+    """Base dataclass that converts the data to a DataArray."""
 
-    @classmethod
-    def from_field(cls, field: Field[Any], value: Any) -> "General":
-        """Create a field model from a dataclass field and a value."""
-        hint = unannotate(field.type)
+    value: Any = MISSING
+    """Actual value of the data."""
 
-        try:
-            return cls(field.name, value, f"{hint.__module__}.{hint.__qualname__}")
-        except AttributeError:
-            return cls(field.name, value, repr(hint))
+    cast: bool = True
+    """Whether the value is cast to the data type."""
+
+    def __call__(self, reference: Optional[DataType] = None) -> xr.DataArray:
+        """Create a DataArray object according to the entry."""
+        ...
 
 
-# data models
 @dataclass(frozen=True)
 class DataModel:
-    """Model for dataclasses or their objects."""
+    """Data representation (data model) inside the package."""
+
+    entries: Dict[str, AnyEntry] = field(default_factory=dict)
+    """Entries of data variable(s) and attribute(s)."""
+
+    @property
+    def attrs(self) -> List[AttrEntry]:
+        """Return a list of attribute entries."""
+        ...
 
-    attr: Dict[str, General] = field(default_factory=dict)
-    """Model of the attribute fields."""
+    @property
+    def coords(self) -> List[DataEntry]:
+        """Return a list of coordinate entries."""
+        ...
 
-    coord: Dict[str, Data] = field(default_factory=dict)
-    """Model of the coordinate fields."""
+    @property
+    def data_vars(self) -> List[DataEntry]:
+        """Return a list of data variable entries."""
+        ...
 
-    data: Dict[str, Data] = field(default_factory=dict)
-    """Model of the data fields."""
+    @property
+    def data_vars_items(self) -> List[Tuple[str, DataEntry]]:
+        """Return a list of data variable entries with keys."""
+        ...
 
-    name: Dict[str, General] = field(default_factory=dict)
-    """Model of the name fields."""
+    @property
+    def names(self) -> List[AttrEntry]:
+        """Return a list of name entries."""
+        ...
 
     @classmethod
     def from_dataclass(cls, dataclass: AnyDataClass[P]) -> "DataModel":
         """Create a data model from a dataclass or its object."""
-        model = cls()
-        eval_dataclass(dataclass)
-
-        for field in dataclass.__dataclass_fields__.values():
-            value = getattr(dataclass, field.name, field.default)
-
-            if FieldType.ATTR.annotates(field.type):
-                model.attr[field.name] = General.from_field(field, value)
-            elif FieldType.COORD.annotates(field.type):
-                model.coord[field.name] = Data.from_field(field, value, False)
-            elif FieldType.COORDOF.annotates(field.type):
-                model.coord[field.name] = Data.from_field(field, value, True)
-            elif FieldType.DATA.annotates(field.type):
-                model.data[field.name] = Data.from_field(field, value, False)
-            elif FieldType.DATAOF.annotates(field.type):
-                model.data[field.name] = Data.from_field(field, value, True)
-            elif FieldType.NAME.annotates(field.type):
-                model.name[field.name] = General.from_field(field, value)
-
-        return model
+        ...
 
 
 # runtime functions