UncountablePythonSDK 0.0.83__py3-none-any.whl → 0.0.132__py3-none-any.whl

pkgs/type_spec/type_info/emit_type_info.py

@@ -3,15 +3,15 @@ import dataclasses
 import decimal
 import io
 import json
-from typing import Any, Optional, Union, cast
+from enum import Enum
+from typing import Any, cast
+
+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,
-)
+from pkgs.serialization_util import serialize_for_api, serialize_for_storage
 
 from .. import builder, util
 from ..emit_typescript_util import MODIFY_NOTICE, ts_name
@@ -41,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
@@ -95,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
@@ -106,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
@@ -129,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]
 
 
-type MapType = Union[MapTypeObject, MapTypeAlias, MapStringEnum]
+MapType = MapTypeObject | MapTypeAlias | MapStringEnum
 
 
 @dataclasses.dataclass
@@ -147,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={})
@@ -172,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[type_info_t.ExtInfo] = None
+    label: str | None = None
+    desc: str | None = None
+    ext_info: type_info_t.ExtInfo | None = None
 
 
 def _extract_inheritable_property_parts(
@@ -201,8 +253,13 @@ def _extract_inheritable_property_parts(
     elif base_parts.ext_info is None:
         ext_info = local_ext_info
     else:
-        ext_info = type_info_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)
@@ -230,7 +287,9 @@ 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:
@@ -262,9 +321,27 @@ def _extract_and_validate_layout(
     return layout
 
 
+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, Optional[type_info_t.ExtInfo]]:
+) -> tuple[ExtInfoLayout | None, type_info_t.ExtInfo | None]:
     ext_info = _parse_ext_info(stype.ext_info)
     if ext_info is None:
         return None, None
@@ -272,9 +349,19 @@ def _validate_type_ext_info(
     if ext_info.label_fields is not None:
         assert stype.properties is not None
         for name in ext_info.label_fields:
-            prop = stype.properties.get(name)
+            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)
     else:
@@ -356,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()
             },
         )
@@ -364,7 +455,7 @@ def _build_map_type(
     return None
 
 
-def _parse_ext_info(in_ext: Any) -> Optional[type_info_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)
@@ -382,10 +473,12 @@ def _parse_ext_info(in_ext: Any) -> Optional[type_info_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]

pkgs/type_spec/value_spec/__main__.py

@@ -13,11 +13,14 @@ One of the following can be specified on the name of a argument:
 After that you can also specify a `!` indicating the argument may not be null.
 If this is not specified, then a null input on this argument should produce a null output.
 We prefer not to use `!` as we want to encourage null pass-through where possible.
-If null is allowed as a legitimate value, such as in conditionals like `if`, then `!` must be specified.
+
+If null is allowed as a legitimate value, such as in conditionals like `is_null`,
+then `!usenull` must be specified, this distinguishes it from the pass-through case.
+The accepted argument type must accept "None", it is not implied.
 """
 
 import sys
-from typing import TypeVar, cast
+from typing import Match, Pattern, TypeVar, cast
 
 import regex as re
 
@@ -53,7 +56,7 @@ class Source:
     def has_more(self) -> bool:
         return self._at < len(self._text)
 
-    def match(self, expression: re.Pattern) -> re.Match | None:
+    def match(self, expression: Pattern[str]) -> Match[str] | None:
         self.skip_space()
         m = expression.match(self._text, self._at)
         if m is not None:
@@ -84,7 +87,7 @@ class Source:
         return self._text[start : self._at]
 
 
-_re_argument_name = re.compile(r"([a-z_]+)(\?|\+)?(!)?:")
+_re_argument_name = re.compile(r"([a-z_]+)(\?|\+)?(!|!usenull)?:")
 
 
 def parse_function_signature(text: str) -> ParsedFunctionSignature:
@@ -101,11 +104,18 @@ def parse_function_signature(text: str) -> ParsedFunctionSignature:
 
         type_str = source.extract_type()
         ref_name = arg_group.group(1)
-        is_missing = arg_group.group(2) == "?"
-        is_repeating = arg_group.group(2) == "+"
-        pass_null = arg_group.group(3) is None
+        # is_missing = arg_group.group(2) == "?"
+        # is_repeating = arg_group.group(2) == "+"
         type_path = parse_type_str(type_str)
 
+        match arg_group.group(3):
+            case "!":
+                on_null = value_spec_t.OnNull.DISALLOW
+            case "!usenull":
+                on_null = value_spec_t.OnNull.USE
+            case _:
+                on_null = value_spec_t.OnNull.PASS
+
         extant = value_spec_t.ArgumentExtant.REQUIRED
         extant_marker = arg_group.group(2)
         if extant_marker == "?":
@@ -116,7 +126,7 @@ def parse_function_signature(text: str) -> ParsedFunctionSignature:
         arguments.append(
             ParsedFunctionArgument(
                 ref_name=ref_name,
-                pass_null=pass_null,
+                on_null=on_null,
                 extant=extant,
                 type_path=type_path,
             )
@@ -145,6 +155,7 @@ key_return = "return"
 key_description = "description"
 key_brief = "brief"
 key_name = "name"
+key_draft = "draft"
 
 
 TypeT = TypeVar("TypeT")
@@ -208,7 +219,7 @@ def main() -> None:
                         name=arg_name,
                         description=arg_description,
                         type=convert_to_value_spec_type(in_argument.type_path),
-                        pass_null=in_argument.pass_null,
+                        on_null=in_argument.on_null,
                         extant=in_argument.extant,
                     )
                 )
@@ -219,6 +230,11 @@ def main() -> None:
 
             brief = get_as(spec, key_brief, str)
             description = get_as(spec, key_description, str)
+            draft = (
+                get_as(spec, key_draft, bool)
+                if spec.get(key_draft) is not None
+                else None
+            )
 
             return_value = get(spec, key_return)
             where.append("return")
@@ -235,6 +251,7 @@ def main() -> None:
                         type=convert_to_value_spec_type(parsed.return_type_path),
                         description=return_description,
                     ),
+                    draft=draft,
                 )
             )
             where.pop()