UncountablePythonSDK 0.0.24__py3-none-any.whl → 0.0.131__py3-none-any.whl

pkgs/type_spec/type_info/emit_type_info.py

@@ -1,11 +1,15 @@
 import copy
 import dataclasses
+import decimal
 import io
 import json
-from typing import Any, Optional, TypeAlias, Union, cast
+from enum import Enum
+from typing import Any, cast
 
-from main.base.types import data_t
-from main.base.types.base import PureJsonValue
+import yaml
+
+from main.base.types import data_t, type_info_t
+from main.base.types.base_t import PureJsonValue
 from pkgs.argument_parser import CachedParser
 from pkgs.serialization_util import serialize_for_api, serialize_for_storage
 
@@ -13,7 +17,7 @@ from .. import builder, util
 from ..emit_typescript_util import MODIFY_NOTICE, ts_name
 from ..value_spec import convert_to_value_spec_type
 
-ext_info_parser = CachedParser(data_t.ExtInfo)
+ext_info_parser = CachedParser(type_info_t.ExtInfo, strict_property_parsing=True)
 
 
 def type_path_of(stype: builder.SpecType) -> object:  # NamePath
@@ -37,10 +41,23 @@ def type_path_of(stype: builder.SpecType) -> object:  # NamePath
             parts: list[object] = ["$literal"]
             for parameter in stype.parameters:
                 assert isinstance(parameter, builder.SpecTypeLiteralWrapper)
+                emit_value = parameter.value
+                if isinstance(parameter.value_type, builder.SpecTypeDefnObject):
+                    emit_value = parameter.value
+                    assert isinstance(emit_value, (str, bool)), (
+                        f"invalid-literal-value:{emit_value}"
+                    )
+                elif isinstance(parameter.value_type, builder.SpecTypeDefnStringEnum):
+                    key = parameter.value
+                    assert isinstance(key, str)
+                    emit_value = parameter.value_type.values[key].value
+                else:
+                    raise Exception("unhandled-literal-type")
+
                 # This allows expansion to enum literal values later
                 parts.append([
                     "$value",
-                    parameter.value,
+                    emit_value,
                     type_path_of(parameter.value_type),
                 ])
             return parts
@@ -69,12 +86,21 @@ def _dict_null_strip(data: dict[str, object]) -> dict[str, object]:
     }
 
 
+class JsonEncoder(json.JSONEncoder):
+    """We have some defaults of special types that we need to emit"""
+
+    def default(self, obj: object) -> object:
+        if isinstance(obj, decimal.Decimal):
+            return str(obj)
+        return json.JSONEncoder.default(self, obj)
+
+
 def emit_type_info(build: builder.SpecBuilder, output: str) -> None:
     type_map = _build_map_all(build)
 
     # sort for stability, indent for smaller diffs
     stripped = _dict_null_strip(dataclasses.asdict(type_map))
-    serial = json.dumps(stripped, sort_keys=True, indent=2)
+    serial = json.dumps(stripped, sort_keys=True, indent=2, cls=JsonEncoder)
     type_map_out = io.StringIO()
     type_map_out.write(MODIFY_NOTICE)
     type_map_out.write(f"export const TYPE_MAP = {serial}")
@@ -82,6 +108,35 @@ def emit_type_info(build: builder.SpecBuilder, output: str) -> None:
     util.rewrite_file(f"{output}/type_map.ts", type_map_out.getvalue())
 
 
+def _convert_value_for_yaml_dump(value: Any) -> Any:
+    if isinstance(value, Enum):
+        return value.value
+    elif isinstance(value, list):
+        return [_convert_value_for_yaml_dump(item) for item in value]
+    elif isinstance(value, dict):
+        return {k: _convert_value_for_yaml_dump(v) for k, v in value.items()}
+    elif isinstance(value, decimal.Decimal):
+        return str(value)
+    else:
+        return value
+
+
+def asdict_for_yaml_dump(dataclass_instance: Any) -> Any:
+    return {
+        k: _convert_value_for_yaml_dump(v)
+        for k, v in dataclasses.asdict(dataclass_instance).items()
+    }
+
+
+def emit_type_info_python(build: builder.SpecBuilder, output: str) -> None:
+    type_map = _build_map_all(build, python=True)
+
+    stripped = _dict_null_strip(asdict_for_yaml_dump(type_map))
+
+    yaml_content = yaml.dump(stripped, default_flow_style=False, sort_keys=True)
+    util.rewrite_file(f"{output}/type_map.yaml", yaml_content)
+
+
 @dataclasses.dataclass
 class MapProperty:
     api_name: str
@@ -93,7 +148,7 @@ class MapProperty:
     desc: str | None
     # We don't have typing on defaults yet, relying on emitters to check it. Limit
     # use of this field, as it'll necessarily change when adding type info
-    default: object
+    default: PureJsonValue
 
 
 @dataclasses.dataclass
@@ -116,12 +171,19 @@ class MapTypeAlias(MapTypeBase):
     discriminator: str | None
 
 
+@dataclasses.dataclass
+class StringEnumValue:
+    value: str
+    label: str
+    deprecated: bool = False
+
+
 @dataclasses.dataclass
 class MapStringEnum(MapTypeBase):
-    values: dict[str, str]
+    values: dict[str, StringEnumValue]
 
 
-MapType: TypeAlias = Union[MapTypeObject, MapTypeAlias, MapStringEnum]
+MapType = MapTypeObject | MapTypeAlias | MapStringEnum
 
 
 @dataclasses.dataclass
@@ -134,11 +196,14 @@ class MapAll:
     namespaces: dict[str, MapNamespace]
 
 
-def _build_map_all(build: builder.SpecBuilder) -> MapAll:
+def _build_map_all(build: builder.SpecBuilder, *, python: bool = False) -> MapAll:
     map_all = MapAll(namespaces={})
 
     for namespace in build.namespaces.values():
-        if not namespace.emit_type_info:
+        if not python and not namespace.emit_type_info:
+            continue
+
+        if python and not namespace.emit_type_info_python:
             continue
 
         map_namespace = MapNamespace(types={})
@@ -159,9 +224,9 @@ class InheritablePropertyParts:
     at that level, but that needs to be done in builder. When that is done, the
     "label" and "desc" could probably be removed from this list."""
 
-    label: Optional[str] = None
-    desc: Optional[str] = None
-    ext_info: Optional[data_t.ExtInfo] = None
+    label: str | None = None
+    desc: str | None = None
+    ext_info: type_info_t.ExtInfo | None = None
 
 
 def _extract_inheritable_property_parts(
@@ -188,8 +253,13 @@ def _extract_inheritable_property_parts(
     elif base_parts.ext_info is None:
         ext_info = local_ext_info
     else:
-        ext_info = data_t.ExtInfo(
-            **(local_ext_info.__dict__ | base_parts.ext_info.__dict__)
+        ext_info = dataclasses.replace(
+            local_ext_info,
+            **{
+                field.name: getattr(base_parts.ext_info, field.name)
+                for field in dataclasses.fields(type_info_t.ExtInfo)
+                if getattr(base_parts.ext_info, field.name) is not None
+            },
         )
 
     return InheritablePropertyParts(label=label, desc=desc, ext_info=ext_info)
@@ -201,7 +271,7 @@ ALL_FIELDS_GROUP = "*all_fields"
 
 def _extract_and_validate_layout(
     stype: builder.SpecTypeDefnObject,
-    ext_info: data_t.ExtInfo,
+    ext_info: type_info_t.ExtInfo,
     base_layout: ExtInfoLayout | None,
 ) -> ExtInfoLayout:
     """
@@ -217,13 +287,15 @@ def _extract_and_validate_layout(
     for group in ext_info.layout.groups:
         fields = set(group.fields or [])
         for field in fields:
-            assert field in stype.properties, f"layout-refers-to-missing-field:{field}"
+            assert field in stype.properties or field == DISCRIMINATOR_COMMON_NAME, (
+                f"layout-refers-to-missing-field:{field}"
+            )
 
         local_ref_name = None
         if group.ref_name is not None:
-            assert (
-                base_layout is None or base_layout.get(group.ref_name) is None
-            ), f"group-name-duplicate-in-base:{group.ref_name}"
+            assert base_layout is None or base_layout.get(group.ref_name) is None, (
+                f"group-name-duplicate-in-base:{group.ref_name}"
+            )
             local_ref_name = group.ref_name
 
         if group.extends:
@@ -242,22 +314,60 @@ def _extract_and_validate_layout(
         assert group_ref_name in layout, f"missing-base-group:{group_ref_name}"
 
     for prop_ref_name in stype.properties:
-        assert prop_ref_name in all_fields_group, f"layout-missing-field:{prop_ref_name}"
+        assert prop_ref_name in all_fields_group, (
+            f"layout-missing-field:{prop_ref_name}"
+        )
 
     return layout
 
 
-def _validate_type_ext_info(stype: builder.SpecTypeDefnObject) -> ExtInfoLayout | None:
+def _pull_property_from_type_recursively(
+    stype: builder.SpecTypeDefnObject,
+    property_name: str,
+) -> builder.SpecProperty | None:
+    assert stype.properties is not None
+    prop = stype.properties.get(property_name)
+    if prop is not None:
+        return prop
+
+    if stype.base is None:
+        return None
+
+    return _pull_property_from_type_recursively(stype.base, property_name)
+
+
+DISCRIMINATOR_COMMON_NAME = "type"
+
+
+def _validate_type_ext_info(
+    stype: builder.SpecTypeDefnObject,
+) -> tuple[ExtInfoLayout | None, type_info_t.ExtInfo | None]:
     ext_info = _parse_ext_info(stype.ext_info)
     if ext_info is None:
-        return None
+        return None, None
+
+    if ext_info.label_fields is not None:
+        assert stype.properties is not None
+        for name in ext_info.label_fields:
+            if name == DISCRIMINATOR_COMMON_NAME:
+                continue
+            prop = _pull_property_from_type_recursively(stype, name)
+            assert prop is not None, f"missing-label-field:{name}"
+
+    if ext_info.actions is not None:
+        assert stype.properties is not None
+        for action in ext_info.actions:
+            if action.property == DISCRIMINATOR_COMMON_NAME:
+                continue
+            prop = _pull_property_from_type_recursively(stype, action.property)
+            assert prop is not None, f"missing-action-field:{action.property}"
 
     if not stype.is_base and isinstance(stype.base, builder.SpecTypeDefnObject):
-        base_layout = _validate_type_ext_info(stype.base)
+        base_layout, _ = _validate_type_ext_info(stype.base)
     else:
         base_layout = None
 
-    return _extract_and_validate_layout(stype, ext_info, base_layout)
+    return _extract_and_validate_layout(stype, ext_info, base_layout), ext_info
 
 
 def _build_map_type(
@@ -270,7 +380,7 @@ def _build_map_type(
         and not stype.is_base
         and stype.base is not None
     ):
-        _validate_type_ext_info(stype)
+        _, ext_info = _validate_type_ext_info(stype)
 
         properties: dict[str, MapProperty] = {}
         map_type = MapTypeObject(
@@ -279,7 +389,7 @@ def _build_map_type(
             properties=properties,
             desc=stype.desc,
             base_type_path=type_path_of(stype.base),
-            ext_info=_convert_ext_info(stype.ext_info),
+            ext_info=serialize_for_api(ext_info),  # type: ignore[arg-type]
         )
 
         if stype.properties is not None:
@@ -293,7 +403,7 @@ def _build_map_type(
                     api_name=ts_name(prop.name, prop.name_case),
                     extant=prop.extant,
                     type_path=type_path_of(prop.spec_type),
-                    ext_info=serialize_for_api(parts.ext_info),
+                    ext_info=serialize_for_api(parts.ext_info),  # type: ignore[arg-type]
                     desc=parts.desc,
                     default=prop.default,
                 )
@@ -311,6 +421,19 @@ def _build_map_type(
             discriminator=stype.discriminator,
         )
 
+    if isinstance(stype, builder.SpecTypeDefnUnion):
+        # Emit as a basic alias for now, as the front-end supports only those for now
+        # IMPROVE: We should emit a proper union type and support that
+        backing = stype.get_backing_type()
+        return MapTypeAlias(
+            type_name=stype.name,
+            label=stype.label,
+            desc=stype.desc,
+            alias_type_path=type_path_of(backing),
+            ext_info=_convert_ext_info(stype.ext_info),
+            discriminator=stype.discriminator,
+        )
+
     if isinstance(stype, builder.SpecTypeDefnStringEnum):
         return MapStringEnum(
             type_name=stype.name,
@@ -320,7 +443,11 @@ def _build_map_type(
             # IMPROVE: We probably want the label here, but this requires a change
             # to the front-end type-info and form code to handle
             values={
-                entry.value: (entry.label or entry.name)
+                entry.value: StringEnumValue(
+                    value=entry.value,
+                    label=entry.label or entry.name,
+                    deprecated=entry.deprecated,
+                )
                 for entry in stype.values.values()
             },
         )
@@ -328,7 +455,7 @@ def _build_map_type(
     return None
 
 
-def _parse_ext_info(in_ext: Any) -> Optional[data_t.ExtInfo]:
+def _parse_ext_info(in_ext: Any) -> type_info_t.ExtInfo | None:
     if in_ext is None:
         return None
     assert isinstance(in_ext, dict)
@@ -346,10 +473,12 @@ def _parse_ext_info(in_ext: Any) -> Optional[data_t.ExtInfo]:
             df["result_type"] = serialize_for_storage(converted)
             mod_ext["data_format"] = df
 
+    if "open_api" in mod_ext:
+        del mod_ext["open_api"]
     return ext_info_parser.parse_storage(mod_ext)
 
 
-def _convert_ext_info(in_ext: Any) -> Optional[PureJsonValue]:
+def _convert_ext_info(in_ext: Any) -> PureJsonValue | None:
     # we need to convert this to API storage since it'll be used as-is in the UI
     parsed = _parse_ext_info(in_ext)
     return cast(PureJsonValue, serialize_for_api(parsed))

pkgs/type_spec/ui_entry_actions/__init__.py

@@ -0,0 +1,4 @@
+# CLOSED MODULE
+from .generate_ui_entry_actions import (
+    generate_entry_actions_typescript as generate_entry_actions_typescript,
+)

pkgs/type_spec/ui_entry_actions/generate_ui_entry_actions.py

@@ -0,0 +1,308 @@
+import json
+import re
+from dataclasses import dataclass
+from io import StringIO
+from pathlib import Path
+from typing import assert_never
+
+from main.base.types import (
+    base_t,
+    ui_entry_actions_t,
+)
+from pkgs.serialization_util import serialize_for_api
+from pkgs.type_spec import emit_typescript_util
+from pkgs.type_spec.builder import (
+    BaseTypeName,
+    NameCase,
+    RawDict,
+    SpecBuilder,
+    SpecNamespace,
+    SpecTypeDefnObject,
+)
+from pkgs.type_spec.config import Config
+from pkgs.type_spec.load_types import load_types
+from pkgs.type_spec.util import rewrite_file
+from pkgs.type_spec.value_spec.convert_type import convert_from_value_spec_type
+
+_INIT_ACTION_INDEX_TYPE_DATA = {
+    "EntryActionInfo<InputT, OutputT>": {
+        "type": BaseTypeName.s_object,
+        "properties": {"inputs": {"type": "InputT"}, "outputs": {"type": "OutputT"}},
+    }
+}
+_TYPES_ROOT = "unc_types"
+
+
+@dataclass(kw_only=True)
+class EntryActionTypeInfo:
+    inputs_type: SpecTypeDefnObject
+    outputs_type: SpecTypeDefnObject
+    name: str
+
+
+def ui_entry_variable_to_type_spec_type(
+    variable: ui_entry_actions_t.UiEntryActionVariable,
+) -> str:
+    match variable:
+        case ui_entry_actions_t.UiEntryActionVariableString():
+            return BaseTypeName.s_string
+        case ui_entry_actions_t.UiEntryActionVariableSingleEntity():
+            return "ObjectId"
+        case _:
+            assert_never(variable)
+
+
+def construct_inputs_type_data(
+    vars: dict[str, ui_entry_actions_t.UiEntryActionVariable],
+) -> RawDict:
+    if len(vars) == 0:
+        return {"type": BaseTypeName.s_object}
+    properties: dict[str, dict[str, str]] = {}
+    for input_name, input_defn in (vars).items():
+        properties[f"{input_name}"] = {
+            "type": ui_entry_variable_to_type_spec_type(input_defn)
+        }
+    return {"type": BaseTypeName.s_object, "properties": properties}
+
+
+def construct_outputs_type_data(
+    vars: dict[str, ui_entry_actions_t.UiEntryActionOutput],
+) -> RawDict:
+    if len(vars) == 0:
+        return {"type": BaseTypeName.s_object}
+    properties: dict[str, dict[str, str]] = {}
+    for output_name, output_defn in (vars).items():
+        # All outputs are optional
+        properties[f"{output_name}"] = {
+            "type": f"Optional<{convert_from_value_spec_type(output_defn.vs_type)}>"
+        }
+    return {"type": BaseTypeName.s_object, "properties": properties}
+
+
+def construct_outputs_type(
+    *,
+    action_scope: ui_entry_actions_t.ActionScope,
+    vars: dict[str, ui_entry_actions_t.UiEntryActionOutput],
+    builder: SpecBuilder,
+    namespace: SpecNamespace,
+) -> SpecTypeDefnObject:
+    stype = SpecTypeDefnObject(
+        namespace=namespace,
+        name=emit_typescript_util.ts_type_name(f"{action_scope}_outputs"),
+    )
+    namespace.types[stype.name] = stype
+    stype.process(
+        builder=builder,
+        data=construct_outputs_type_data(vars=vars),
+    )
+    return stype
+
+
+def construct_inputs_type(
+    *,
+    action_scope: ui_entry_actions_t.ActionScope,
+    vars: dict[str, ui_entry_actions_t.UiEntryActionVariable],
+    builder: SpecBuilder,
+    namespace: SpecNamespace,
+) -> SpecTypeDefnObject:
+    stype = SpecTypeDefnObject(
+        namespace=namespace,
+        name=emit_typescript_util.ts_type_name(f"{action_scope}_inputs"),
+    )
+    stype.process(builder=builder, data=construct_inputs_type_data(vars))
+    namespace.types[stype.name] = stype
+    return stype
+
+
+def _get_types_root(destination_root: Path) -> Path:
+    return destination_root / "types"
+
+
+def emit_imports_ts(
+    namespaces: set[SpecNamespace],
+    out: StringIO,
+) -> None:
+    for ns in sorted(
+        namespaces,
+        key=lambda ns: ns.name,
+    ):
+        import_as = emit_typescript_util.resolve_namespace_ref(ns)
+        import_from = f"{_TYPES_ROOT}/{ns.name}"
+        out.write(f'import * as {import_as} from "{import_from}"\n')
+
+
+def emit_entry_action_definition(
+    *,
+    ctx: emit_typescript_util.EmitTypescriptContext,
+    defn: ui_entry_actions_t.UiEntryActionDefinition,
+    builder: SpecBuilder,
+    action_scope: ui_entry_actions_t.ActionScope,
+) -> EntryActionTypeInfo:
+    inputs_type = construct_inputs_type(
+        action_scope=action_scope,
+        vars=defn.inputs,
+        builder=builder,
+        namespace=ctx.namespace,
+    )
+    outputs_type = construct_outputs_type(
+        action_scope=action_scope,
+        vars=defn.outputs,
+        builder=builder,
+        namespace=ctx.namespace,
+    )
+
+    return EntryActionTypeInfo(
+        inputs_type=inputs_type,
+        outputs_type=outputs_type,
+        name=action_scope,
+    )
+
+
+def _validate_input(input: ui_entry_actions_t.UiEntryActionVariable) -> None:
+    if "_" in input.vs_var_name:
+        raise ValueError(f"Expected camelCase for variable {input.vs_var_name}")
+    if not re.fullmatch(base_t.REF_NAME_STRICT_REGEX, input.vs_var_name):
+        raise ValueError(
+            f"Variable {input.vs_var_name} has invalid syntax. See REF_NAME_STRICT_REGEX"
+        )
+
+
+def emit_query_index(
+    ctx: emit_typescript_util.EmitTypescriptContext,
+    defn_infos: list[EntryActionTypeInfo],
+    index_path: Path,
+    builder: SpecBuilder,
+    definitions: dict[
+        ui_entry_actions_t.ActionScope, ui_entry_actions_t.UiEntryActionDefinition
+    ],
+) -> bool:
+    query_index_type_data = {
+        **_INIT_ACTION_INDEX_TYPE_DATA,
+        "EntityActionTypeLookup": {
+            "type": BaseTypeName.s_object,
+            "properties": {
+                defn_info.name: {
+                    "type": f"EntryActionInfo<{defn_info.inputs_type.name},{defn_info.outputs_type.name}>",
+                    "name_case": NameCase.preserve,
+                }
+                for defn_info in defn_infos
+            },
+        },
+        "InputInfo": {
+            "type": BaseTypeName.s_object,
+            "properties": {
+                "value_spec_var": {"type": "String"},
+                "type": {"type": "ui_entry_actions.UiEntryActionDataType"},
+                "variable": {"type": "ui_entry_actions.UiEntryActionVariable"},
+            },
+        },
+        "OutputInfo": {
+            "type": BaseTypeName.s_object,
+            "properties": {
+                "name": {"type": "String"},
+                "desc": {"type": "String"},
+                "type": {"type": "value_spec.BaseType"},
+            },
+        },
+        "DefinitionInfo": {
+            "type": BaseTypeName.s_object,
+            "properties": {
+                "inputs": {
+                    "type": "ReadonlyArray<InputInfo>",
+                },
+                "outputs": {
+                    "type": "ReadonlyArray<OutputInfo>",
+                },
+            },
+        },
+    }
+    ctx.namespace.prescan(query_index_type_data)
+    ctx.namespace.process(
+        builder=builder,
+        data=query_index_type_data,
+    )
+
+    defn_lookup_info = {}
+    for scope, defn in definitions.items():
+        inputs = []
+        outputs = []
+        for input in defn.inputs.values():
+            _validate_input(input)
+            inputs.append(
+                serialize_for_api({
+                    "value_spec_var": input.vs_var_name,
+                    "type": input.type,
+                    "variable": input,
+                })
+            )
+        for name, output in defn.outputs.items():
+            outputs.append(
+                serialize_for_api({
+                    "name": name,
+                    "desc": output.description,
+                    "type": output.vs_type,
+                })
+            )
+        defn_lookup_info[scope] = {"inputs": inputs, "outputs": outputs}
+
+    defn_lookup_out = f"export const DEFINITION_LOOKUP = {json.dumps(defn_lookup_info, sort_keys=True, indent=2)} as const\n\nexport const DEFINITION_LOOKUP_TYPED = DEFINITION_LOOKUP as Record<UiEntryActionsT.ActionScope, DefinitionInfo>\n"
+
+    for stype in ctx.namespace.types.values():
+        emit_typescript_util.emit_type_ts(
+            ctx=ctx,
+            stype=stype,
+        )
+
+    import_buffer = StringIO()
+    emit_typescript_util.emit_namespace_imports_from_root_ts(
+        namespaces=ctx.namespaces,
+        out=import_buffer,
+        root=_TYPES_ROOT,
+    )
+
+    return rewrite_file(
+        content=import_buffer.getvalue() + ctx.out.getvalue() + defn_lookup_out,
+        filename=str(index_path),
+    )
+
+
+def generate_entry_actions_typescript(
+    *,
+    definitions: dict[
+        ui_entry_actions_t.ActionScope, ui_entry_actions_t.UiEntryActionDefinition
+    ],
+    destination_root: Path,
+    materials_type_spec_config: Config,
+) -> None:
+    builder = load_types(materials_type_spec_config)
+    assert builder is not None
+
+    definition_buffer = StringIO()
+    index_namespace = SpecNamespace(name="index")
+    ctx = emit_typescript_util.EmitTypescriptContext(
+        out=definition_buffer,
+        namespace=index_namespace,
+        api_endpoints={},
+    )
+    builder.namespaces[index_namespace.name] = index_namespace
+
+    defn_infos: list[EntryActionTypeInfo] = []
+
+    for action_scope, defn in definitions.items():
+        defn_infos.append(
+            emit_entry_action_definition(
+                action_scope=action_scope,
+                ctx=ctx,
+                defn=defn,
+                builder=builder,
+            )
+        )
+
+    index_path = _get_types_root(destination_root) / "index.ts"
+    emit_query_index(
+        ctx=ctx,
+        builder=builder,
+        defn_infos=defn_infos,
+        definitions=definitions,
+        index_path=index_path,
+    )

pkgs/type_spec/util.py

@@ -1,7 +1,7 @@
 import json
 import os
 from dataclasses import dataclass
-from typing import Optional, TypeVar, Union
+from typing import TypeVar, Union
 
 import regex as re
 
@@ -29,8 +29,8 @@ LiteralTypeValue = Union[str, bool]
 class ParsedTypePart:
     name: str
     # An empty list is distinct from None
-    parameters: Optional[list["ParsedTypePath"]] = None
-    literal_value: Optional[LiteralTypeValue] = None
+    parameters: list["ParsedTypePath"] | None = None
+    literal_value: LiteralTypeValue | None = None
 
 
 ParsedTypePath = list[ParsedTypePart]
@@ -159,7 +159,7 @@ def is_valid_property_name(name: str) -> bool:
 def check_fields(data: dict[str, T], allowed: list[str]) -> None:
     for key in data:
         if key not in allowed:
-            raise Exception(f"unexpected-field: {key}")
+            raise Exception(f"unexpected-field: {key}. Allowed: {allowed}")
 
 
 def split_any_name(name: str) -> list[str]: