UncountablePythonSDK 0.0.110__py3-none-any.whl → 0.0.112__py3-none-any.whl

docs/conf.py

@@ -6,10 +6,10 @@
 # -- Project information -----------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
 
-from datetime import date
+import datetime
 
 project = "Uncountable SDK"
-copyright = f"{date.today().year}, Uncountable Inc"
+copyright = f"{datetime.datetime.now(tz=datetime.UTC).date().year}, Uncountable Inc"
 author = "Uncountable Inc"
 
 # -- General configuration ---------------------------------------------------

docs/justfile

@@ -1,5 +1,5 @@
 docs-setup-python:
-  curl -LsSf https://astral.sh/uv/0.6.1/install.sh | sh
+  curl -LsSf https://astral.sh/uv/0.7.1/install.sh | sh
   uv pip install -r requirements.txt
 
 docs-clean:

examples/create_ingredient_sdk.py

@@ -0,0 +1,34 @@
+import os
+
+import uncountable.types.api.inputs.create_inputs as create_inputs
+from uncountable.core import AuthDetailsApiKey, Client
+from uncountable.types import field_values_t, inputs_t
+
+client = Client(
+    base_url="http://localhost:5000",
+    auth_details=AuthDetailsApiKey(
+        api_id=os.environ["UNC_API_ID"],
+        api_secret_key=os.environ["UNC_API_SECRET_KEY"],
+    ),
+)
+
+client.external_create_inputs(
+    inputs_to_create=[
+        create_inputs.InputToCreate(
+            name="sdk test ing",
+            material_family_ids=[1],
+            quantity_type=inputs_t.IngredientQuantityType.NUMERIC,
+            type=inputs_t.IngredientType.INGREDIENT,
+            field_values=[
+                field_values_t.FieldRefNameValue(
+                    field_ref_name="carrieTestNumericField",
+                    value="10",
+                ),
+                field_values_t.FieldRefNameValue(
+                    field_ref_name="carrieTestCheckboxField",
+                    value=True,
+                ),
+            ],
+        )
+    ]
+)

examples/integration-server/jobs/materials_auto/example_runsheet_wh.py

@@ -0,0 +1,35 @@
+from io import BytesIO
+
+from uncountable.core.file_upload import DataFileUpload, FileUpload
+from uncountable.integration.job import JobArguments, RunsheetWebhookJob, register_job
+from uncountable.types import entity_t
+
+
+@register_job
+class StandardRunsheetGenerator(RunsheetWebhookJob):
+    def build_runsheet(
+        self,
+        *,
+        args: JobArguments,
+        entities: list[entity_t.Entity],
+    ) -> FileUpload:
+        args.logger.log_info(f"Generating runsheet for {len(entities)} entities")
+
+        content = []
+        content.append("STANDARD LAB RUNSHEET\n")
+        content.append("=" * 30 + "\n\n")
+
+        for entity in entities:
+            content.append(f"Type: {entity.type}\n")
+            content.append(f"ID: {entity.id}\n")
+
+            if hasattr(entity, "field_values") and entity.field_values:
+                content.append("Field Values:\n")
+                for field in entity.field_values:
+                    content.append(f"  - {field.name}: {field.value}\n")
+
+            content.append("\n")
+
+        runsheet_data = "".join(content).encode("utf-8")
+
+        return DataFileUpload(name="lab_runsheet.txt", data=BytesIO(runsheet_data))

examples/integration-server/jobs/materials_auto/profile.yaml

@@ -41,3 +41,12 @@ jobs:
     executor:
       type: script
       import_path: example_wh
+  - id: example_runsheet_wh
+    type: webhook
+    name: Runsheet Webhook
+    signature_key_secret:
+      type: env
+      env_key: WH_RUNSHEET_SIGNATURE_KEY
+    executor:
+      type: script
+      import_path: example_runsheet_wh

examples/integration-server/pyproject.toml

@@ -16,7 +16,8 @@ dependencies = [
   "types-requests == 2.*",
   "types-simplejson == 3.*",
   "pandas-stubs",
-  "xlrd == 2.*"
+  "xlrd == 2.*",
+  "msgspec == 0.19.*"
 ]
 
 [tool.mypy]
@@ -221,4 +222,3 @@ max-locals=50
 
 [tool.setuptools]
 py-modules = []
-

pkgs/argument_parser/argument_parser.py

@@ -1,24 +1,25 @@
 from __future__ import annotations
 
 import dataclasses
+import datetime
 import math
 import types
 import typing
 from abc import ABC, abstractmethod
 from collections import defaultdict
-from datetime import date, datetime
+from datetime import date
 from decimal import Decimal
 from enum import Enum, auto
 from importlib import resources
 
 import dateutil.parser
+import msgspec.yaml
 
 from pkgs.serialization import (
     MissingSentryType,
     OpaqueKey,
     get_serial_class_data,
     get_serial_union_data,
-    yaml,
 )
 
 from ._is_enum import is_string_enum_class
@@ -335,10 +336,12 @@ def _build_parser_inner(
 
         return parse_int
 
-    if parsed_type is datetime:
+    if parsed_type is datetime.datetime:
 
         def parse_datetime(value: typing.Any) -> T:
-            if context.options.allow_direct_type and isinstance(value, datetime):
+            if context.options.allow_direct_type and isinstance(
+                value, datetime.datetime
+            ):
                 return value  # type: ignore
             return dateutil.parser.isoparse(value)  # type:ignore
 
@@ -561,11 +564,11 @@ class ParserBase(ABC, typing.Generic[T]):
 
     def parse_yaml_file(self, path: str) -> T:
         with open(path, encoding="utf-8") as data_in:
-            return self.parse_storage(yaml.safe_load(data_in))
+            return self.parse_storage(msgspec.yaml.decode(data_in.read()))
 
     def parse_yaml_resource(self, package: resources.Package, resource: str) -> T:
         with resources.open_text(package, resource) as fp:
-            return self.parse_storage(yaml.safe_load(fp))
+            return self.parse_storage(msgspec.yaml.decode(fp.read()))
 
 
 class CachedParser(ParserBase[T], typing.Generic[T]):

pkgs/type_spec/builder.py

@@ -624,7 +624,12 @@ class SpecTypeDefnUnion(SpecTypeDefn):
                 prop_type = unwrap_literal_type(discriminator_type.spec_type)
                 assert prop_type is not None
                 assert prop_type.is_value_to_string()
-                discriminant = str(prop_type.value)
+                value_type = prop_type.value_type
+                if isinstance(value_type, SpecTypeDefnStringEnum):
+                    assert isinstance(prop_type.value, str)
+                    discriminant = value_type.values[prop_type.value].value
+                else:
+                    discriminant = str(prop_type.value)
                 assert discriminant not in self.discriminator_map, (
                     f"duplicated-discriminant, {discriminant} in {sub_type}"
                 )
@@ -793,6 +798,7 @@ class SpecTypeDefnStringEnum(SpecTypeDefn):
 TOKEN_ENDPOINT = "$endpoint"
 TOKEN_EMIT_IO_TS = "$emit_io_ts"
 TOKEN_EMIT_TYPE_INFO = "$emit_type_info"
+TOKEN_EMIT_TYPE_INFO_PYTHON = "$emit_type_info_python"
 # The import token is only for explicit ordering of the files, to process constants
 # and enums correctly. It does not impact the final generation of files, or the
 # language imports. Those are still auto-resolved.
@@ -1161,6 +1167,7 @@ class SpecNamespace:
         self.endpoint: SpecEndpoint | None = None
         self.emit_io_ts = False
         self.emit_type_info = False
+        self.emit_type_info_python = False
         self.derive_types_from_io_ts = False
         self._imports: list[str] | None = None
         self.path = name.split(".")
@@ -1215,6 +1222,11 @@ class SpecNamespace:
                 self.emit_type_info = defn
                 continue
 
+            if name == TOKEN_EMIT_TYPE_INFO_PYTHON:
+                assert defn in (True, False)
+                self.emit_type_info_python = defn
+                continue
+
             if name == TOKEN_IMPORT:
                 assert self._imports is None
                 imports = [defn] if isinstance(defn, str) else defn
@@ -1276,7 +1288,12 @@ class SpecNamespace:
                 parsed_name = parse_type_str(full_name)[0]
                 name = parsed_name.name
 
-                if name in [TOKEN_EMIT_IO_TS, TOKEN_EMIT_TYPE_INFO, TOKEN_IMPORT]:
+                if name in [
+                    TOKEN_EMIT_IO_TS,
+                    TOKEN_EMIT_TYPE_INFO,
+                    TOKEN_IMPORT,
+                    TOKEN_EMIT_TYPE_INFO_PYTHON,
+                ]:
                     continue
 
                 builder.push_where(name)

pkgs/type_spec/emit_python.py

@@ -5,7 +5,7 @@ from decimal import Decimal
 from typing import Any
 
 from . import builder, util
-from .builder import EndpointEmitType, EndpointSpecificPath
+from .builder import EndpointEmitType, EndpointSpecificPath, base_namespace_name
 from .config import PythonConfig
 from .cross_output_links import get_path_links
 from .emit_open_api_util import EmitOpenAPIStabilityLevel
@@ -907,13 +907,19 @@ def _emit_type(ctx: Context, stype: builder.SpecType) -> None:
 
     # Emit dataclass decorator
     dataclass = "@dataclasses.dataclass"
-    dc_args = []
+    refer_to(
+        ctx,
+        builder.SpecTypeDefnAlias(
+            namespace=ctx.builder.namespaces[base_namespace_name], name="ENABLE_SLOTS"
+        ),
+    )
+    dc_args = ["slots=base_t.ENABLE_SLOTS"]
     if stype.is_kw_only():
         dc_args.append("kw_only=True")
     if stype.is_hashable:
         dc_args.extend(["frozen=True", "eq=True"])
     if len(dc_args) > 0:
-        dataclass += f"({', '.join(dc_args)})"
+        dataclass += f"({', '.join(dc_args)})  # type: ignore[literal-required]"
 
     ctx.out.write(f"{dataclass}\n")
     ctx.out.write(class_out.getvalue())

pkgs/type_spec/emit_typescript_util.py

@@ -103,7 +103,7 @@ def emit_value_ts(
     elif isinstance(stype, builder.SpecTypeDefnStringEnum):
         return f"{refer_to(ctx, stype)}.{ts_enum_name(value, stype.name_case)}"
 
-    raise Exception("invalid constant type", value, stype)
+    raise Exception("invalid constant type", value, stype, type(stype))
 
 
 def emit_type_ts(ctx: EmitTypescriptContext, stype: builder.SpecType) -> None:
@@ -266,3 +266,18 @@ def emit_namespace_imports_ts(
         )
         import_from = f"{import_path}{resolve_namespace_name(ns)}"
         out.write(f'import * as {import_as} from "{import_from}"\n')  # noqa: E501
+
+
+def emit_namespace_imports_from_root_ts(
+    namespaces: set[builder.SpecNamespace],
+    out: io.StringIO,
+    root: str,
+) -> None:
+    for ns in sorted(
+        namespaces,
+        key=lambda name: resolve_namespace_name(name),
+    ):
+        import_as = resolve_namespace_ref(ns)
+        out.write(
+            f'import * as {import_as} from "{root}/{resolve_namespace_name(ns)}"\n'
+        )  # noqa: E501

pkgs/type_spec/parts/base.py.prepart

@@ -28,6 +28,10 @@ REF_NAME_STRICT_REGEX = rf"{REF_NAME_STRICT_REGEX_STRING}"
 ID_REGEX = r"-?[1-9][0-9]{0,20}"
 
 
+# ENABLE_SLOTS should be removed after slots have been tested locally
+import os
+ENABLE_SLOTS = os.environ.get("UNC_ENABLE_DATACLASS_SLOTS") == "true"
+
 if TYPE_CHECKING:
     JsonValue = Union[JsonScalar, Mapping[str, "JsonValue"], Sequence["JsonValue"]]
     ExtJsonValue = JsonValue

pkgs/type_spec/type_info/emit_type_info.py

@@ -116,7 +116,7 @@ def asdict_for_yaml_dump(dataclass_instance: Any) -> Any:
 
 
 def emit_type_info_python(build: builder.SpecBuilder, output: str) -> None:
-    type_map = _build_map_all(build)
+    type_map = _build_map_all(build, python=True)
 
     stripped = _dict_null_strip(asdict_for_yaml_dump(type_map))
 
@@ -176,11 +176,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={})
@@ -324,6 +327,12 @@ def _validate_type_ext_info(
             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:
+            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:

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,294 @@
+import json
+from dataclasses import dataclass
+from io import StringIO
+from pathlib import Path
+from typing import assert_never
+
+from main.base.types import (
+    ui_entry_actions_t,
+)
+from pkgs.argument_parser import snake_to_camel_case
+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.UiEntryActionVariableEntityFields():
+            return "entity.Entity"
+        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 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"},
+                "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 name, input in defn.inputs.items():
+            inputs.append(
+                serialize_for_api({
+                    "value_spec_var": snake_to_camel_case(name),
+                    "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,
+    )
+    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/value_spec/convert_type.py

@@ -61,3 +61,16 @@ def convert_to_value_spec_type(parsed: ParsedTypePath) -> value_spec_t.ValueType
     return value_spec_t.ValueType(base_type=mapped.base_type, parameters=parameters)
 
     # Our formatter was duplicating the previous line for an unknown reason, this comment blocks that
+
+
+def convert_from_value_spec_type(
+    base_type: value_spec_t.BaseType,
+) -> str:
+    for type_spec_type, mapped_type in TYPE_MAP.items():
+        if (
+            mapped_type.base_type == base_type
+            and mapped_type.param_count == 0
+            and mapped_type.variable_param_count is False
+        ):
+            return type_spec_type
+    raise ValueError(f"invalid value spec type {base_type}")