xradio 0.0.56__py3-none-any.whl → 0.0.58__py3-none-any.whl

xradio/schema/check.py

@@ -1,3 +1,4 @@
+import builtins
 import dataclasses
 import typing
 import inspect
@@ -15,6 +16,8 @@ from xradio.schema import (
     xarray_dataclass_to_dataset_schema,
     xarray_dataclass_to_dict_schema,
 )
+from xradio.schema.dataclass import value_schema
+from xradio.schema.metamodel import AttrSchemaRef, ValueSchema
 
 
 @dataclasses.dataclass
@@ -295,7 +298,8 @@ def check_dtype(dtype: numpy.dtype, expected: [numpy.dtype]) -> SchemaIssues:
     :returns: List of :py:class:`SchemaIssue`s found
     """
 
-    for exp_dtype in expected:
+    for exp_dtype_str in expected:
+        exp_dtype = numpy.dtype(exp_dtype_str)
         # If the expected dtype has no size (e.g. "U", a.k.a. a string of
         # arbitrary length), we don't check itemsize, only kind.
         if (
@@ -312,7 +316,7 @@ def check_dtype(dtype: numpy.dtype, expected: [numpy.dtype]) -> SchemaIssues:
             SchemaIssue(
                 path=[("dtype", None)],
                 message="Wrong numpy dtype",
-                found=dtype,
+                found=dtype.str,
                 expected=list(expected),
             )
         ]
@@ -334,30 +338,23 @@ def check_attributes(
 
     issues = SchemaIssues()
     for attr_schema in attrs_schema:
-        # Attribute missing? Note that a value of "None" is equivalent for the
-        # purpose of the check
+        # Attribute missing is equivalent to a value of "None" is
+        # equivalent for the purpose of the check
         val = attrs.get(attr_schema.name)
         if val is None:
             if not attr_schema.optional:
-                # Get options
-                if typing.get_origin(attr_schema.typ) is typing.Union:
-                    options = typing.get_args(attr_schema.typ)
-                else:
-                    options = [attr_schema.typ]
-
                 issues.add(
                     SchemaIssue(
                         path=[(attr_kind, attr_schema.name)],
-                        message=f"Required attribute {attr_schema.name} is missing!",
-                        expected=options,
+                        message="Non-optional attribute is missing!",
+                        found=None,
+                        expected=[attr_schema.type],
                     )
                 )
             continue
 
-        # Check attribute value
-        issues += _check_value_union(val, attr_schema.typ).at_path(
-            attr_kind, attr_schema.name
-        )
+        # Check actual value
+        issues += _check_value(val, attr_schema).at_path(attr_kind, attr_schema.name)
 
     # Extra attributes are always okay
 
@@ -385,7 +382,6 @@ def check_data_vars(
 
     issues = SchemaIssues()
     for data_var_schema in data_vars_schema:
-
         allow_mutiple_versions = False
         for attr in data_var_schema.attributes:
             if hasattr(attr, "name"):
@@ -450,125 +446,103 @@ def check_dict(
     return check_attributes(dct, schema.attributes, attr_kind="")
 
 
-def _check_value(val, ann):
+def _check_value(val: typing.Any, schema: metamodel.ValueSchema):
     """
     Check whether value satisfies annotation
 
     If the annotation is a data array or dataset schema, it will be checked.
 
     :param val: Value to check
-    :param ann: Type annotation of value
+    :param schema: Schema of value
     :returns: Schema issues
     """
 
+    # Unspecified?
+    if schema.type is None:
+        return SchemaIssues()
+
+    # Optional?
+    if schema.optional and val is None:
+        return SchemaIssues()
+
     # Is supposed to be a data array?
-    if bases.is_dataarray_schema(ann):
+    if schema.type == "dataarray":
         # Attempt to convert dictionaries automatically
         if isinstance(val, dict):
             try:
                 val = xarray.DataArray.from_dict(val)
             except ValueError as e:
+                expected = [DataArray]
+                if schema.optional:
+                    expected.append(type(None))
                 return SchemaIssues(
                     [
                         SchemaIssue(
-                            path=[], message=str(e), expected=[ann], found=type(val)
+                            path=[], message=str(e), expected=expected, found=type(val)
                         )
                     ]
                 )
             except TypeError as e:
+                expected = [DataArray]
+                if schema.optional:
+                    expected.append(type(None))
                 return SchemaIssues(
                     [
                         SchemaIssue(
-                            path=[], message=str(e), expected=[ann], found=type(val)
+                            path=[], message=str(e), expected=expected, found=type(val)
                         )
                     ]
                 )
 
         if not isinstance(val, xarray.DataArray):
             # Fall through to plain type check
-            ann = xarray.DataArray
-        else:
-            return check_array(val, ann)
-
-    # Is supposed to be a dataset?
-    if bases.is_dataset_schema(ann):
-        # Attempt to convert dictionaries automatically
-        if isinstance(val, dict):
-            try:
-                val = xarray.Dataset.from_dict(val)
-            except ValueError as e:
-                return SchemaIssues(
-                    [
-                        SchemaIssue(
-                            path=[], message=str(t), expected=[ann], found=type(val)
-                        )
-                    ]
-                )
-        if not isinstance(val, xarray.Dataset):
-            # Fall through to plain type check
-            ann = xarray.Dataset
+            type_to_check = xarray.DataArray
         else:
-            return check_dataset(val, ann)
+            return check_array(val, schema.array_schema)
 
     # Is supposed to be a dictionary?
-    if bases.is_dict_schema(ann):
+    elif schema.type == "dict":
         if not isinstance(val, dict):
             # Fall through to plain type check
-            ann = dict
+            type_to_check = dict
         else:
-            return check_dict(val, ann)
+            return check_dict(val, schema.dict_schema)
+
+    elif schema.type == "list[str]":
+        type_to_check = typing.List[str]
+    elif schema.type in ["bool", "str", "int", "float"]:
+        type_to_check = getattr(builtins, schema.type)
+    else:
+        raise ValueError(f"Invalid typ_name in schema: {schema.type}")
 
     # Otherwise straight type check using typeguard
     try:
-        check_type(val, ann)
+        check_type(val, type_to_check)
     except TypeCheckError as t:
+        expected = [type_to_check]
+        if schema.optional:
+            expected.append(type(None))
         return SchemaIssues(
-            [SchemaIssue(path=[], message=str(t), expected=[ann], found=type(val))]
+            [SchemaIssue(path=[], message=str(t), expected=expected, found=type(val))]
         )
 
-    return SchemaIssues()
-
-
-def _check_value_union(val, ann):
-    """
-    Check whether value satisfies annotations, including union types
-
-    If the annotation is a data array or dataset schema, it will be checked.
-
-    :param val: Value to check
-    :param ann: Type annotation of value
-    :returns: Schema issues
-    """
-
-    if ann is None or ann is inspect.Signature.empty:
-        return SchemaIssues()
-
-    # Account for union types (this especially catches "Optional")
-    if typing.get_origin(ann) is typing.Union:
-        options = typing.get_args(ann)
-    else:
-        options = [ann]
-
-    # Go through options, try to find one without issues
-    args_issues = None
-    okay = False
-    for option in options:
-        arg_issues = _check_value(val, option)
-        # We can immediately return if we find no issues with
-        # some schema check
-        if not arg_issues:
-            return SchemaIssues()
-        if args_issues is None:
-            args_issues = arg_issues
-
-        # Crude merging of expected options (for "unexpected type")
-        elif len(args_issues) == 1 and len(arg_issues) == 1:
-            args_issues[0].expected += arg_issues[0].expected
+    # List of literals given?
+    if schema.literal is not None:
+        for lit in schema.literal:
+            if val == lit:
+                return SchemaIssues()
+        return SchemaIssues(
+            [
+                SchemaIssue(
+                    path=[],
+                    message=f"Disallowed literal value!",
+                    expected=schema.literal,
+                    found=val,
+                )
+            ]
+        )
 
-    # Return representative issues list
-    if not args_issues:
-        raise ValueError("Empty union set?")
-    return args_issues
+    return SchemaIssues()
 
 
 _DATASET_TYPES = {}
@@ -591,7 +565,7 @@ def register_dataset_type(schema: metamodel.DatasetSchema):
             continue
 
         # Type should be a kind of literal
-        if typing.get_origin(attr.typ) is not typing.Literal:
+        if attr.literal is None:
             warnings.warn(
                 f"In dataset schema {schema.schema_name}:"
                 'Attribute "type" should be a literal!'
@@ -599,7 +573,12 @@ def register_dataset_type(schema: metamodel.DatasetSchema):
             continue
 
         # Register type names
-        for typ in typing.get_args(attr.typ):
+        for typ in attr.literal:
+            assert isinstance(typ, str), (
+                f"In dataset schema {schema.schema_name}:"
+                'Attribute "type" should be a literal giving '
+                "names of schema!"
+            )
             _DATASET_TYPES[typ] = schema
 
 
@@ -621,7 +600,6 @@ def check_datatree(
     # Loop through all groups in datatree
     issues = SchemaIssues()
     for xds_name in datatree.groups:
-
         # Ignore any leaf without data
         node = datatree[xds_name]
         if not node.has_data:
@@ -679,7 +657,7 @@ def schema_checked(fn, check_parameters: bool = True, check_return: bool = True)
     @functools.wraps(fn)
     def _check_fn(*args, **kwargs):
         # Hide this function in pytest tracebacks
-        __tracebackhide__ = True
+        # __tracebackhide__ = True
 
         # Bind parameters, collect (potential) issues
         bound = signature.bind(*args, **kwargs)
@@ -689,7 +667,15 @@ def schema_checked(fn, check_parameters: bool = True, check_return: bool = True)
                 continue
 
             # Get annotation
-            issues += _check_value_union(val, anns.get(arg)).at_path(arg)
+            vschema = value_schema(anns.get(arg), "function", arg)
+            pseudo_attr_schema = AttrSchemaRef(
+                name=arg,
+                **{
+                    fld.name: getattr(vschema, fld.name)
+                    for fld in dataclasses.fields(ValueSchema)
+                },
+            )
+            issues += _check_value(val, pseudo_attr_schema).at_path(arg)
 
         # Any issues found? raise
         issues.expect()
@@ -699,7 +685,15 @@ def schema_checked(fn, check_parameters: bool = True, check_return: bool = True)
 
         # Check return
         if check_return:
-            issues = _check_value_union(val, signature.return_annotation)
+            vschema = value_schema(anns.get(arg), "function", "return")
+            pseudo_attr_schema = AttrSchemaRef(
+                name="return",
+                **{
+                    fld.name: getattr(vschema, fld.name)
+                    for fld in dataclasses.fields(ValueSchema)
+                },
+            )
+            issues = _check_value(val, pseudo_attr_schema)
             issues.at_path("return").expect()
 
         # Check return value

xradio/schema/dataclass.py

@@ -76,7 +76,6 @@ def _check_invalid_dims(
 
     # Filter out dimension possibilities with undefined coordinates
     valid_dims = [ds for ds in dims if set(ds).issubset(all_coord_names)]
-    # print(f"{klass_name}.{field_name}", valid_dims, dims, all_coord_names)
 
     # Raise an exception if this makes the dimension set impossible
     if dims and not valid_dims:
@@ -88,6 +87,132 @@ def _check_invalid_dims(
     return valid_dims
 
 
+def value_schema(ann: typing.Any, klass_name: str, field_name: str) -> "ValueSchema":
+    """
+    Take attribute type annotation and convert into type name and
+    - optionally - a list of literal allowed values
+
+    :param ann: Annotation
+    :param klass_name: Name of class where annotation origins from
+    :param field_name: Name of field where annotation origins from
+    :returns: ValueSchema
+    """
+
+    # No annotation?
+    if ann is None:
+        return ValueSchema(None)
+
+    # Optional?
+    if is_optional(ann):
+
+        # Optional is actually represented as a union... Construct
+        # same union type without the "None" type.
+        typs = [typ for typ in get_args(ann) if typ is not None.__class__]
+        if len(typs) == 1:
+            typ = typs[0]
+        else:
+            raise ValueError(
+                f"In '{klass_name}', field '{field_name}' has"
+                f" a union type, which is not allowed!"
+            )
+
+        # Convert to schema recursively
+        vschema = value_schema(typ, klass_name, field_name)
+        vschema.optional = True
+        return vschema
+
+    # Is a type?
+    if isinstance(ann, type):
+        # Array type?
+        if hasattr(ann, "__xradio_array_schema"):
+            return ValueSchema("dataarray", array_schema=ann.__xradio_array_schema)
+
+        # Dictionary type?
+        if hasattr(ann, "__xradio_dict_schema"):
+            return ValueSchema("dict", dict_schema=ann.__xradio_dict_schema)
+
+        # Check that it is an allowable type
+        if ann not in [bool, str, int, float, bool]:
+            raise ValueError(
+                f"In '{klass_name}', field '{field_name}' has"
+                f" type {ann} - but only str, int, float or list are allowed!"
+            )
+        return ValueSchema(ann.__name__)
+
+    # Is a list
+    if typing.get_origin(ann) in [typing.List, list]:
+        args = typing.get_args(ann)
+
+        # Must be a string list
+        if args != (str,):
+            raise ValueError(
+                f"In '{klass_name}', field '{field_name}' has"
+                f" annotation {ann}, but only str, int, float, list[str] or Literal allowed!"
+            )
+
+        return ValueSchema("list[str]")
+
+    # Is a literal?
+    if typing.get_origin(ann) is typing.Literal:
+        args = typing.get_args(ann)
+
+        # Check that it is an allowable type
+        if len(args) == 0:
+            raise ValueError(
+                f"In '{klass_name}', field '{field_name}' has"
+                f" literal annotation, but allows no values!"
+            )
+
+        # String list?
+        typ = type(args[0])
+        if typ is list:
+            elem_type = type(args[0][0])
+            if elem_type is not str:
+                raise ValueError(
+                    f"In '{klass_name}', field '{field_name}' has"
+                    f" literal type list[{elem_type}] - but only list[str] is allowed!"
+                )
+            for lit in args:
+                if not isinstance(lit, typ):
+                    raise ValueError(
+                        f"In '{klass_name}', field '{field_name}' literal"
+                        f" {lit} has inconsistent type ({typ(lit)}) vs ({typ})!"
+                    )
+                for elem in lit:
+                    if not isinstance(elem, elem_type):
+                        raise ValueError(
+                            f"In '{klass_name}', field '{field_name}' literal"
+                            f" {lit} has inconsistent element type "
+                            f"({typ(elem)}) vs ({elem_type})!"
+                        )
+            return ValueSchema(
+                "list[str]",
+                literal=[[str(elem) for elem in arg] for arg in args],
+            )
+
+        # Check that it is an allowable type
+        if typ not in [bool, str, int, float]:
+            raise ValueError(
+                f"In '{klass_name}', field '{field_name}' has"
+                f" literal type {typ} - but only str, int, float or list[str] are allowed!"
+            )
+
+        # Check that all literals have the same type
+        for lit in args:
+            if not isinstance(lit, typ):
+                raise ValueError(
+                    f"In '{klass_name}', field '{field_name}' literal"
+                    f" {lit} has inconsistent type ({typ(lit)}) vs ({typ})!"
+                )
+
+        return ValueSchema(typ.__name__, literal=[typ(arg) for arg in args])
+
+    raise ValueError(
+        f"In '{klass_name}', field '{field_name}' has"
+        f" annotation {ann}, but only type or Literal allowed!"
+    )
+
+
 def extract_xarray_dataclass(klass, allow_undefined_coords: bool = False):
     """
     Go through dataclass fields and interpret them according to xarray-dataclass
@@ -132,13 +257,27 @@ def extract_xarray_dataclass(klass, allow_undefined_coords: bool = False):
 
         # Is it an attribute?
         if role == Role.ATTR:
+            try:
+                ann = get_annotated(typ)
+            except TypeError as e:
+                raise ValueError(
+                    f"Could not get annotation in '{klass.__name__}' field '{field.name}': {e}"
+                )
+            vschema = value_schema(get_annotated(typ), klass.__name__, field.name)
+            if is_optional(typ):
+                vschema.optional = True
+
             attributes.append(
                 AttrSchemaRef(
                     name=field.name,
-                    typ=get_annotated(typ),
-                    optional=is_optional(typ),
-                    default=field.default,
+                    default=(
+                        None if field.default is dataclasses.MISSING else field.default
+                    ),
                     docstring=field_docstrings.get(field.name),
+                    **{
+                        fld.name: getattr(vschema, fld.name)
+                        for fld in dataclasses.fields(ValueSchema)
+                    },
                 )
             )
             continue
@@ -151,7 +290,7 @@ def extract_xarray_dataclass(klass, allow_undefined_coords: bool = False):
         else:
             raise ValueError(
                 f"Expected field '{field.name}' in '{klass.__name__}' "
-                "to be annotated with either Coord, Data or Attr!"
+                f"to be annotated with either Coord, Data or Attr!"
             )
 
         # Defined using a dataclass, i.e. Coordof/Dataof?
@@ -173,7 +312,7 @@ def extract_xarray_dataclass(klass, allow_undefined_coords: bool = False):
             schema_ref = ArraySchemaRef(
                 name=field.name,
                 optional=is_optional(typ),
-                default=field.default,
+                default=None if field.default is dataclasses.MISSING else field.default,
                 docstring=field_docstrings.get(field.name),
                 **arr_schema_fields,
             )
@@ -206,7 +345,9 @@ def extract_xarray_dataclass(klass, allow_undefined_coords: bool = False):
                 schema_ref = ArraySchemaRef(
                     name=field.name,
                     optional=is_optional(typ),
-                    default=field.default,
+                    default=(
+                        None if field.default is dataclasses.MISSING else field.default
+                    ),
                     docstring=field_docstrings.get(field.name),
                     **arr_schema_fields,
                 )
@@ -215,11 +356,13 @@ def extract_xarray_dataclass(klass, allow_undefined_coords: bool = False):
                 schema_ref = ArraySchemaRef(
                     name=field.name,
                     optional=is_optional(typ),
-                    default=field.default,
+                    default=(
+                        None if field.default is dataclasses.MISSING else field.default
+                    ),
                     docstring=field_docstrings.get(field.name),
                     schema_name=None,
                     dimensions=check_invalid_dims(dims, field.name),
-                    dtypes=[numpy.dtype(typ) for typ in types],
+                    dtypes=[numpy.dtype(typ).str for typ in types],
                     coordinates=[],
                     attributes=[],
                     class_docstring=None,
@@ -281,7 +424,7 @@ def xarray_dataclass_to_array_schema(klass):
     schema = ArraySchema(
         schema_name=f"{klass.__module__}.{klass.__qualname__}",
         dimensions=data_vars[0].dimensions,
-        dtypes=data_vars[0].dtypes,
+        dtypes=[numpy.dtype(dt).str for dt in data_vars[0].dtypes],
         coordinates=coordinates,
         attributes=attributes,
         class_docstring=inspect.cleandoc(klass.__doc__),
@@ -369,22 +512,16 @@ def xarray_dataclass_to_dict_schema(klass):
     for field in dataclasses.fields(klass):
         typ = type_hints[field.name]
 
-        # Handle optional value: Strip "None" from the types
-        optional = is_optional(typ)
-        if optional:
-            typs = [typ for typ in get_args(typ) if typ is not None.__class__]
-            if len(typs) == 1:
-                typ = typs[0]
-            else:
-                typ = typing.Union.__getitem__[tuple(typs)]
-
+        vschema = value_schema(typ, klass.__name__, field.name)
         attributes.append(
             AttrSchemaRef(
                 name=field.name,
-                typ=typ,
-                optional=optional,
-                default=field.default,
+                default=None if field.default is dataclasses.MISSING else field.default,
                 docstring=field_docstrings.get(field.name),
+                **{
+                    fld.name: getattr(vschema, fld.name)
+                    for fld in dataclasses.fields(ValueSchema)
+                },
             )
         )
 

xradio/schema/export.py

@@ -0,0 +1,99 @@
+import dataclasses
+import json
+
+from xradio.schema import (
+    bases,
+    metamodel,
+    xarray_dataclass_to_array_schema,
+    xarray_dataclass_to_dataset_schema,
+    xarray_dataclass_to_dict_schema,
+)
+
+CLASS_ATTR = "$class"
+
+
+class DataclassEncoder(json.JSONEncoder):
+    """
+    General-purpose encoder that represents data classes as
+    dictionaries, omitting defaults and annotating the original class
+    as a ``'$class'`` attribute.
+    """
+
+    def default(self, o):
+        if dataclasses.is_dataclass(o):
+            res = {CLASS_ATTR: o.__class__.__name__}
+            for fld in dataclasses.fields(type(o)):
+                if (
+                    getattr(o, fld.name) is not fld.default
+                    and getattr(o, fld.name) is not dataclasses.MISSING
+                ):
+                    res[fld.name] = getattr(o, fld.name)
+            return res
+        return super().default(o)
+
+
+DATACLASS_MAP = {
+    cls.__name__: cls
+    for cls in [
+        metamodel.DictSchema,
+        metamodel.ValueSchema,
+        metamodel.AttrSchemaRef,
+        metamodel.ArraySchema,
+        metamodel.ArraySchemaRef,
+        metamodel.DatasetSchema,
+    ]
+}
+
+
+class DataclassDecoder(json.JSONDecoder):
+    """
+    General-purpose decoder that reads JSON as generated by
+    :py:class:`DataclassEncoder`.
+    """
+
+    def __init__(self, dataclass_map, *args, **kwargs):
+        self._dataclass_map = dataclass_map
+        super().__init__(*args, object_hook=self.object_hook, **kwargs)
+
+    def object_hook(self, obj):
+
+        # Detect dictionaries with '$class' annotation
+        if isinstance(obj, dict) and CLASS_ATTR in obj:
+
+            # Identify the class
+            cls_name = obj[CLASS_ATTR]
+            cls = self._dataclass_map.get(cls_name)
+            if not cls:
+                raise ValueError(
+                    f"Unknown $dataclass encountered while decoding JSON: {cls_name}"
+                )
+
+            # Instantiate
+            del obj[CLASS_ATTR]
+            obj = cls(**obj)
+
+        return obj
+
+
+def export_schema_json_file(schema, fname):
+    """
+    Exports given schema as a JSON file
+    """
+
+    # Check that this is actually a Dataset
+    if bases.is_dataset_schema(schema):
+        schema = xarray_dataclass_to_dataset_schema(schema)
+    if not isinstance(schema, metamodel.DatasetSchema):
+        raise TypeError(
+            f"export_schema_json_file: Expected DatasetSchema, but got {type(schema)}!"
+        )
+
+    # Perform export
+    with open(fname, "w", encoding="utf8") as f:
+        json.dump(schema, f, cls=DataclassEncoder, ensure_ascii=False, indent="  ")
+
+
+def import_schema_json_file(fname):
+
+    with open(fname, "r", encoding="utf8") as f:
+        return json.load(f, cls=DataclassDecoder, dataclass_map=DATACLASS_MAP)