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

pkgs/type_spec/emit_typescript_util.py

@@ -1,24 +1,42 @@
 import io
+import typing
 from dataclasses import dataclass, field
 
 from . import builder, util
-from .config import TypeScriptConfig
+from .builder_types import CrossOutputPaths
 
 INDENT = "  "
 
 MODIFY_NOTICE = "// DO NOT MODIFY -- This file is generated by type_spec\n"
 
+base_name_map = {
+    builder.BaseTypeName.s_boolean: "boolean",
+    builder.BaseTypeName.s_date: "string",  # IMPROVE: Aliased DateStr
+    builder.BaseTypeName.s_date_time: "string",  # IMPROVE: Aliased DateTimeStr
+    # Decimal's are marked as to_string_values thus are strings in the front-end
+    builder.BaseTypeName.s_decimal: "string",
+    builder.BaseTypeName.s_dict: "PartialRecord",
+    builder.BaseTypeName.s_integer: "number",
+    builder.BaseTypeName.s_lossy_decimal: "number",
+    builder.BaseTypeName.s_opaque_key: "string",
+    builder.BaseTypeName.s_none: "null",
+    builder.BaseTypeName.s_string: "string",
+    # UNC: global types
+    builder.BaseTypeName.s_json_value: "JsonValue",
+}
+
 
 @dataclass(kw_only=True)
 class EmitTypescriptContext:
-    config: TypeScriptConfig
     out: io.StringIO
     namespace: builder.SpecNamespace
     namespaces: set[builder.SpecNamespace] = field(default_factory=set)
+    cross_output_paths: CrossOutputPaths | None = None
+    api_endpoints: dict[builder.EndpointKey, builder.APIEndpointInfo]
 
 
 def ts_type_name(name: str) -> str:
-    return "".join([x.capitalize() for x in name.split("_")])
+    return "".join([x.title() for x in name.split("_")])
 
 
 def resolve_namespace_ref(namespace: builder.SpecNamespace) -> str:
@@ -29,4 +47,275 @@ def ts_name(name: str, name_case: builder.NameCase) -> str:
     if name_case == builder.NameCase.preserve:
         return name
     bits = util.split_any_name(name)
-    return "".join([bits[0], *[x.capitalize() for x in bits[1:]]])
+    return "".join([bits[0], *[x.title() for x in bits[1:]]])
+
+
+def emit_value_ts(
+    ctx: EmitTypescriptContext,
+    stype: builder.SpecType,
+    value: typing.Any,
+    indent: int = 0,
+) -> str:
+    """Mimics emit_python even if not all types are used in TypeScript yet"""
+    literal = builder.unwrap_literal_type(stype)
+    if literal is not None:
+        return emit_value_ts(ctx, literal.value_type, literal.value)
+
+    if stype.is_base_type(builder.BaseTypeName.s_string):
+        assert isinstance(value, str)
+        return util.encode_common_string(value)
+    elif stype.is_base_type(builder.BaseTypeName.s_integer):
+        assert isinstance(value, int)
+        return str(value)
+    elif stype.is_base_type(builder.BaseTypeName.s_boolean):
+        assert isinstance(value, bool)
+        return "true" if value else "false"
+    elif stype.is_base_type(builder.BaseTypeName.s_lossy_decimal):
+        return str(value)
+    elif stype.is_base_type(builder.BaseTypeName.s_decimal):
+        return f"'{value}'"
+    elif isinstance(stype, builder.SpecTypeInstance):
+        if stype.defn_type.is_base_type(builder.BaseTypeName.s_list):
+            sub_type = stype.parameters[0]
+            return (
+                "[" + ", ".join([emit_value_ts(ctx, sub_type, x) for x in value]) + "]"
+            )
+
+        if stype.defn_type.is_base_type(builder.BaseTypeName.s_dict):
+            key_type = stype.parameters[0]
+            value_type = stype.parameters[1]
+
+            if not key_type.is_base_type(
+                builder.BaseTypeName.s_string
+            ) and not isinstance(key_type, builder.SpecTypeDefnStringEnum):
+                raise Exception("invalid dict keys -- dict keys must be string or enum")
+
+            return (
+                f"{{\n{INDENT * (indent + 1)}"
+                + f",\n{INDENT * (indent + 1)}".join(
+                    (
+                        f"[{emit_value_ts(ctx, key_type, dkey)}]: "
+                        if not key_type.is_base_type(builder.BaseTypeName.s_string)
+                        else f"{dkey}: "
+                    )
+                    + emit_value_ts(ctx, value_type, dvalue, indent=indent + 1)
+                    for dkey, dvalue in value.items()
+                )
+                + f"\n{INDENT * (indent)}}}"
+            )
+
+        if stype.defn_type.is_base_type(builder.BaseTypeName.s_optional):
+            sub_type = stype.parameters[0]
+            if value is None:
+                return "null"
+            return emit_value_ts(ctx, sub_type, value)
+
+    elif isinstance(stype, builder.SpecTypeDefnStringEnum):
+        return f"{refer_to(ctx, stype)}.{ts_enum_name(value, stype.name_case)}"
+    elif isinstance(stype, builder.SpecTypeDefnObject):
+        assert isinstance(value, dict), (
+            f"Expected dict value for {stype.name} but got {value}"
+        )
+        obj_out = "{"
+        did_emit = False
+        for prop_name, prop in (stype.properties or {}).items():
+            if prop_name not in value and prop.has_default:
+                value_to_emit = prop.default
+            elif prop_name not in value:
+                continue
+            else:
+                value_to_emit = value[prop_name]
+            did_emit = True
+            typescript_name = ts_name(prop.name, prop.name_case)
+            obj_out += f"\n{INDENT * (indent + 1)}{typescript_name}: {emit_value_ts(ctx, prop.spec_type, value_to_emit, indent=indent + 1)},"
+        whitespace = f"\n{INDENT * indent}" if did_emit else ""
+        obj_out += f"{whitespace}}} as const"
+        return obj_out
+
+    raise Exception("invalid constant type", value, stype, type(stype))
+
+
+def emit_constant_ts(ctx: EmitTypescriptContext, sconst: builder.SpecConstant) -> None:
+    ctx.out.write("\n\n")
+    ctx.out.write(MODIFY_NOTICE)
+    value = emit_value_ts(ctx, sconst.value_type, sconst.value)
+    const_name = sconst.name.upper()
+    ctx.out.write(f"export const {const_name} = {value}\n")
+
+
+def emit_type_ts(ctx: EmitTypescriptContext, stype: builder.SpecType) -> None:
+    if not isinstance(stype, builder.SpecTypeDefn):
+        return
+
+    if stype.is_base or stype.is_predefined:
+        return
+
+    ctx.out.write("\n")
+    ctx.out.write(MODIFY_NOTICE)
+
+    if isinstance(stype, builder.SpecTypeDefnExternal):
+        assert not stype.is_exported, "expecting private names"
+        ctx.out.write("\n")
+        ctx.out.write(stype.external_map["ts"])
+        ctx.out.write("\n")
+        return
+
+    assert stype.is_exported, "expecting exported names"
+    if isinstance(stype, builder.SpecTypeDefnAlias):
+        ctx.out.write(f"export type {stype.name} = {refer_to(ctx, stype.alias)}\n")
+        return
+
+    if isinstance(stype, builder.SpecTypeDefnUnion):
+        ctx.out.write(
+            f"export type {stype.name} = {refer_to(ctx, stype.get_backing_type())}\n"
+        )
+        return
+
+    if isinstance(stype, builder.SpecTypeDefnStringEnum):
+        ctx.out.write(f"export enum {stype.name} {{\n")
+        assert stype.values
+        for name, entry in stype.values.items():
+            ctx.out.write(
+                f'{INDENT}{ts_enum_name(name, stype.name_case)} = "{entry.value}",\n'
+            )
+        ctx.out.write("}\n")
+        return
+
+    assert isinstance(stype, builder.SpecTypeDefnObject)
+    assert stype.base is not None
+
+    base_type = ""
+    if not stype.base.is_base:
+        base_type = f"{refer_to(ctx, stype.base)} & "
+
+    if stype.properties is None and base_type == "":
+        ctx.out.write(f"export type {stype.name} = TEmpty\n")
+    elif stype.properties is None:
+        ctx.out.write(f"export type {stype.name} = {base_type}{{}}\n")
+    else:
+        if isinstance(stype, builder.SpecTypeDefnObject) and len(stype.parameters) > 0:
+            full_type_name = f"{stype.name}<{', '.join(stype.parameters)}>"
+        else:
+            full_type_name = stype.name
+        ctx.out.write(f"export type {full_type_name} = {base_type}{{")
+        ctx.out.write("\n")
+        for prop in stype.properties.values():
+            ref_type = refer_to(ctx, prop.spec_type)
+            prop_name = ts_name(prop.name, prop.name_case)
+            if prop.has_default and not prop.parse_require:
+                # For now, we'll assume the generated types with defaults are meant as
+                # arguments, thus treat like extant==missing
+                # IMPROVE: if we can decide they are meant as output instead, then
+                # they should be marked as required
+                ctx.out.write(f"{INDENT}{prop_name}?: {ref_type}")
+            elif prop.extant == builder.PropertyExtant.missing:
+                # Unlike optional below, missing does not imply null is possible. They
+                # treated distinctly.
+                ctx.out.write(f"{INDENT}{prop_name}?: {ref_type}")
+            elif prop.extant == builder.PropertyExtant.optional:
+                # Need to add in |null since Python side can produce null's right now
+                # IMPROVE: It would be better if the serializer could instead omit the None's
+                # Dropping the null should be forward compatible
+                ctx.out.write(f"{INDENT}{prop_name}?: {ref_type} | null")
+            else:
+                ctx.out.write(f"{INDENT}{prop_name}: {ref_type}")
+            ctx.out.write("\n")
+        ctx.out.write("}\n")
+
+
+def refer_to(ctx: EmitTypescriptContext, stype: builder.SpecType) -> str:
+    return refer_to_impl(ctx, stype)[0]
+
+
+def refer_to_impl(
+    ctx: EmitTypescriptContext, stype: builder.SpecType
+) -> tuple[str, bool]:
+    """
+    @return (string-specific, multiple-types)
+    """
+    if isinstance(stype, builder.SpecTypeInstance):
+        if stype.defn_type.name == builder.BaseTypeName.s_list:
+            spec, multi = refer_to_impl(ctx, stype.parameters[0])
+            return f"({spec})[]" if multi else f"{spec}[]", False
+        if stype.defn_type.name == builder.BaseTypeName.s_readonly_array:
+            spec, multi = refer_to_impl(ctx, stype.parameters[0])
+            return f"readonly ({spec})[]" if multi else f"readonly {spec}[]", False
+        if stype.defn_type.name == builder.BaseTypeName.s_union:
+            return (
+                f"({' | '.join([refer_to(ctx, p) for p in stype.parameters])})",
+                False,
+            )
+        if stype.defn_type.name == builder.BaseTypeName.s_literal:
+            parts = []
+            for parameter in stype.parameters:
+                assert isinstance(parameter, builder.SpecTypeLiteralWrapper)
+                parts.append(refer_to(ctx, parameter))
+            return f"({' | '.join(parts)})", False
+        if stype.defn_type.name == builder.BaseTypeName.s_optional:
+            return f"{refer_to(ctx, stype.parameters[0])} | null", True
+        if stype.defn_type.name == builder.BaseTypeName.s_tuple:
+            return f"[{', '.join([refer_to(ctx, p) for p in stype.parameters])}]", False
+        params = ", ".join([refer_to(ctx, p) for p in stype.parameters])
+        return f"{refer_to(ctx, stype.defn_type)}<{params}>", False
+
+    if isinstance(stype, builder.SpecTypeLiteralWrapper):
+        return emit_value_ts(ctx, stype.value_type, stype.value), False
+
+    if isinstance(stype, builder.SpecTypeGenericParameter):
+        return stype.name, False
+
+    assert isinstance(stype, builder.SpecTypeDefn)
+    if stype.is_base:  # assume correct namespace
+        if stype.name == builder.BaseTypeName.s_list:
+            return "any[]", False  # TODO: generic type
+        return base_name_map[builder.BaseTypeName(stype.name)], False
+
+    if stype.namespace == ctx.namespace:
+        return stype.name, False
+
+    ctx.namespaces.add(stype.namespace)
+    return f"{resolve_namespace_ref(stype.namespace)}.{stype.name}", False
+
+
+def ts_enum_name(name: str, name_case: builder.NameCase) -> str:
+    if name_case == builder.NameCase.js_upper:
+        return name.upper()
+    return ts_name(name, name_case)
+
+
+def resolve_namespace_name(namespace: builder.SpecNamespace) -> str:
+    return namespace.name
+
+
+def emit_namespace_imports_ts(
+    namespaces: set[builder.SpecNamespace],
+    out: io.StringIO,
+    current_namespace: builder.SpecNamespace,
+) -> None:
+    for ns in sorted(
+        namespaces,
+        key=lambda name: resolve_namespace_name(name),
+    ):
+        import_as = resolve_namespace_ref(ns)
+        import_path = (
+            "./"
+            if len(current_namespace.path) == 1
+            else "../" * (len(current_namespace.path) - 1)
+        )
+        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/load_types.py

@@ -1,12 +1,13 @@
 import os
 from collections.abc import Callable
 from io import StringIO
-from typing import Optional
 
-import yaml
 from shelljob import fs
 
+from pkgs.serialization import yaml
+
 from .builder import SpecBuilder
+from .builder_types import CrossOutputPaths
 from .config import Config
 
 ext_map = {
@@ -40,8 +41,23 @@ def find_and_handle_files(
             handler(file_name, file.read())
 
 
-def load_types(config: Config) -> Optional[SpecBuilder]:
-    builder = SpecBuilder(api_endpoints=config.api_endpoint)
+def load_types(config: Config) -> SpecBuilder | None:
+    if config.typescript is not None and config.python is not None:
+        cross_output_paths = CrossOutputPaths(
+            python_types_output=config.python.types_output,
+            typescript_types_output=config.typescript.types_output,
+            typescript_routes_output_by_endpoint=config.typescript.endpoint_to_routes_output,
+            typespec_files_input=config.type_spec_types,
+            # IMPROVE not sure how to know which one is the correct one in emit_typescript
+        )
+    else:
+        cross_output_paths = None
+
+    builder = SpecBuilder(
+        api_endpoints=config.api_endpoint,
+        top_namespace=config.top_namespace,
+        cross_output_paths=cross_output_paths,
+    )
 
     def handle_builder_add(
         file_name: str, file_content: str, handler: Callable[[str, str, str], None]
@@ -114,4 +130,3 @@ def load_types(config: Config) -> Optional[SpecBuilder]:
         return None
 
     return builder
-    return True

pkgs/type_spec/non_discriminated_union_exceptions.py

@@ -0,0 +1,14 @@
+NON_DISCRIMINATED_UNION_EXCEPTIONS = [
+    "generate_tool_parameters.UnionWithoutDiscrim",
+    "output_calculation_entities.ConditionParameterFilterCondition",
+    "output_parameters.AnalyticalMethodParameterOptions",
+    "output_parameters.AnalyticalMethodLinkedOptionValue",
+    "recipes_redirect.RecipesRedirectResult",
+    "value_spec.ResolvedPathAll",
+    "weighted_sum.WeightedSumEntities",
+    "workflows.WorkflowTotalDisplay",
+    "type_info.TypeFormActionConstraint",
+    "structured_loading.CompatibleFilterNode",
+    "structured_display_element.DisplayElementColumn",
+    "field_values.FieldValue",
+]

pkgs/type_spec/open_api_util.py

@@ -1,15 +1,23 @@
 from abc import ABC, abstractmethod
 from enum import StrEnum
-from typing import Optional
+
+from pkgs.serialization_util import JsonValue
 
 
 class OpenAPIType(ABC):
     description: str | None = None
     nullable: bool = False
+    default: JsonValue
 
-    def __init__(self, description: str | None = None, nullable: bool = False) -> None:
+    def __init__(
+        self,
+        description: str | None = None,
+        nullable: bool = False,
+        default: JsonValue = None,
+    ) -> None:
         self.description = description
         self.nullable = nullable
+        self.default = default
 
     @abstractmethod
     def asdict(self) -> dict[str, object]:
@@ -20,6 +28,8 @@ class OpenAPIType(ABC):
             emitted["description"] = self.description
         if self.nullable:
             emitted["nullable"] = self.nullable
+        if self.default is not None:
+            emitted["default"] = self.default
         return emitted
 
 
@@ -158,7 +168,7 @@ class OpenAPIObjectType(OpenAPIType):
         description: str | None = None,
         nullable: bool = False,
         *,
-        property_desc: Optional[dict[str, str]] = None,
+        property_desc: dict[str, str] | None = None,
     ) -> None:
         self.properties = properties
         if property_desc is None:
@@ -213,13 +223,28 @@ class OpenAPIUnionType(OpenAPIType):
         base_types: list[OpenAPIType],
         description: str | None = None,
         nullable: bool = False,
+        discriminator: str | None = None,
+        discriminator_map: dict[str, OpenAPIRefType] | None = None,
     ) -> None:
         self.base_types = base_types
+        self._discriminator = discriminator
+        self._discriminator_map = discriminator_map
         super().__init__(description=description, nullable=nullable)
 
     def asdict(self) -> dict[str, object]:
         # TODO: use parents description and nullable
-        return {"oneOf": [base_type.asdict() for base_type in self.base_types]}
+        return {
+            "oneOf": [base_type.asdict() for base_type in self.base_types],
+            "discriminator": {
+                "propertyName": self._discriminator,
+                "mapping": {
+                    discriminator_value: base_type.source
+                    for discriminator_value, base_type in self._discriminator_map.items()
+                },
+            }
+            if self._discriminator is not None and self._discriminator_map is not None
+            else None,
+        }
 
 
 class OpenAPIIntersectionType(OpenAPIType):

pkgs/type_spec/parts/base.py.prepart

@@ -22,10 +22,16 @@ PureJsonScalar = Union[str, float, bool, None]
 # Regular expressions for identifying ref names and IDs. Ref names should be
 # using this regular expression as a constriant in the database.
 REF_NAME_REGEX = r"^[a-zA-Z0-9_/-]+$"
-# Does not support nonpositive integers at the moment.
-ID_REGEX = r"[1-9][0-9]{0,20}"
+REF_NAME_STRICT_REGEX_STRING = "^[a-zA-Z_][a-zA-Z0-9_]*$"
+REF_NAME_STRICT_REGEX = rf"{REF_NAME_STRICT_REGEX_STRING}"
+# Ids matching a strict integer number are converted to integers
+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
@@ -52,15 +58,12 @@ def is_pure_json_value(value: ExtJsonValue) -> bool:
         return True
 
     if isinstance(value, list):
-        for item in value:
-            if not is_pure_json_value(item):
-                return False
-        return True
+        return all(is_pure_json_value(item) for item in value)
 
     if isinstance(value, dict):
-        for key, item in value.items():
-            if not is_pure_json_value(key) or not is_pure_json_value(item):
-                return False
-        return True
+        return all(
+            is_pure_json_value(key) and is_pure_json_value(item)
+            for key, item in value.items()
+        )
 
     return False

pkgs/type_spec/parts/base.ts.prepart

@@ -3,6 +3,7 @@
 // doesn't allow referring explicitly to global names (thus cannot override here)
 // IMPROVE: invert relationship for global.d.ts looks here instead
 import * as IO from 'io-ts';
+
 type localJsonScalar = JsonScalar
 type localJsonValue = JsonValue
 type localObjectId = ObjectId
@@ -28,3 +29,6 @@ export const IOJsonValue: IO.Type<JsonValue> = IO.recursion('JsonValue', () =>
 export interface nominal<T> {
   "nominal structural brand": T
 }
+
+// Ids matching a strict integer number are converted to integers
+export const ID_REGEX = /-?[1-9][0-9]{0,20}/

pkgs/type_spec/type_info/__main__.py

@@ -9,7 +9,7 @@ import sys
 
 from ..config import parse_yaml_config
 from ..load_types import load_types
-from .emit_type_info import emit_type_info
+from .emit_type_info import emit_type_info, emit_type_info_python
 
 
 def main() -> bool:
@@ -26,6 +26,8 @@ def main() -> bool:
 
     assert config.typescript is not None
     emit_type_info(builder, config.typescript.type_info_output)
+    if config.python.type_info_output is not None:
+        emit_type_info_python(builder, config.python.type_info_output)
 
     return True