UncountablePythonSDK 0.0.192__py3-none-any.whl → 0.0.194__py3-none-any.whl

examples/integration-server/pyproject.toml

@@ -16,7 +16,7 @@ dependencies = [
   "types-simplejson ==4.*",
   "pandas-stubs",
   "xlrd == 2.*",
-  "msgspec ==0.21.*",
+  "msgspec ==0.22.*",
   "websockets==17.0",
 ]
 

pkgs/argument_parser/__init__.py

@@ -19,6 +19,7 @@ __all__ = [
     "is_string_enum_class",
     "is_union",
     "kebab_to_pascal_case",
+    "parse_fallback_legacy_type",
     "resolve_serialized_field_name",
     "snake_to_camel_case",
 ]
@@ -36,6 +37,7 @@ from .case_convert import (
 from .field_name_resolution import (
     resolve_serialized_field_name as resolve_serialized_field_name,
 )
+from .parse_fallback import parse_fallback_legacy_type as parse_fallback_legacy_type
 from .parser_base import ParserBase as ParserBase
 from .parser_builder import build_parser as build_parser
 from .parser_error import (

pkgs/type_spec/builder.py

@@ -17,7 +17,7 @@ import regex
 from pkgs.serialization import Usage
 
 from . import util
-from .builder_types import CrossOutputPaths, PythonParseFallback
+from .builder_types import CrossOutputPaths
 from .non_discriminated_union_exceptions import NON_DISCRIMINATED_UNION_EXCEPTIONS
 from .util import parse_type_str
 
@@ -83,6 +83,7 @@ class SpecProperty:
     has_default: bool = False
     # Requires this value in parsing, even if it has a default
     parse_require: bool = False
+    sensitive: bool = False
     desc: str | None = None
     # Holds extra information that will be emitted along with type_info. The builder knows nothing
     # about the contents of this information.
@@ -103,6 +104,11 @@ class PropertyNameMode(StrEnum):
     deprecated_non_snake_case = "deprecated_non_snake_case"
 
 
+class StringEnumEmitMode(StrEnum):
+    STANDARD = "standard"
+    SOURCE_ENUM_ALIAS = "source_enum_alias"
+
+
 class BaseTypeName(StrEnum):
     """
     Base types that are supported.
@@ -412,6 +418,7 @@ class SpecTypeDefn(SpecType):
                 "extant",
                 "label",
                 "name_case",
+                "sensitive",
                 "type",
             ],
         )
@@ -494,6 +501,11 @@ class SpecTypeDefn(SpecType):
 
             ext_info = data.get("ext_info")
             label = data.get("label")
+            sensitive = data.get("sensitive", False)
+            builder.ensure(
+                isinstance(sensitive, bool),
+                f"sensitive must be a boolean for property {name}",
+            )
 
             return SpecProperty(
                 name=name,
@@ -506,6 +518,7 @@ class SpecTypeDefn(SpecType):
                 has_default=has_default,
                 default=default,
                 parse_require=parse_require,
+                sensitive=sensitive,
                 desc=data.get("desc", None),
                 ext_info=ext_info,
                 explicit_default=explicit_default,
@@ -527,6 +540,13 @@ class SpecTypeDefn(SpecType):
         return self.namespace.usage
 
 
+@dataclass(kw_only=True, frozen=True)
+class PythonParseFallback:
+    legacy_property: str
+    convert_namespace: SpecNamespace
+    convert: str
+
+
 class SpecTypeGenericParameter(SpecType):
     def __init__(
         self,
@@ -692,13 +712,22 @@ class SpecTypeDefnObject(SpecTypeDefn):
                 isinstance(legacy_property, str) and isinstance(convert, str),
                 f"python_parse_fallbacks: {property_name} legacy_property and convert must be strings",
             )
+            convert_namespace_path, _, convert_function = convert.rpartition(".")
+            convert_namespace = builder.namespaces.get(convert_namespace_path)
+            builder.ensure(
+                convert_namespace is not None,
+                f"python_parse_fallbacks: {property_name} convert must be <namespace>.<function> with a known namespace, got {convert}",
+            )
+            assert convert_namespace is not None
             builder.ensure_python_prepart_function(
-                namespace_name=self.namespace.name,
-                function_name=convert,
+                namespace=convert_namespace,
+                function_name=convert_function,
                 option_name="python_parse_fallbacks",
             )
             parse_fallbacks[property_name] = PythonParseFallback(
-                legacy_property=legacy_property, convert=convert
+                legacy_property=legacy_property,
+                convert_namespace=convert_namespace,
+                convert=convert_function,
             )
         return parse_fallbacks
 
@@ -912,6 +941,8 @@ class SpecTypeDefnStringEnum(SpecTypeDefn):
         self.desc: str | None = None
         self.sql_type_name: str | None = None
         self.emit_id_source = False
+        self.emit_mode = StringEnumEmitMode.STANDARD
+        self.alias_source_enum: SpecTypeDefnStringEnum | None = None
         self.source_enums: list[SpecType] = []
         self.property_name_mode = PropertyNameMode.strict
 
@@ -1036,12 +1067,15 @@ class SpecTypeDefnStringEnum(SpecTypeDefn):
 
         emit_data = data.get("emit")
         if emit_data is not None:
-            util.check_fields(emit_data, ["id_source"])
+            util.check_fields(emit_data, ["id_source", "mode"])
             emit_id_source = emit_data.get("id_source", False)
             assert isinstance(emit_id_source, bool)
             self.emit_id_source = emit_id_source
             if emit_id_source:
                 builder.emit_id_source_enums.add(self)
+            self.emit_mode = StringEnumEmitMode(
+                emit_data.get("mode", StringEnumEmitMode.STANDARD.value)
+            )
 
         if self.emit_id_source:
             assert len(self.namespace.path) == 1
@@ -1062,10 +1096,41 @@ class SpecTypeDefnStringEnum(SpecTypeDefn):
         for name in self.values:
             _validate_enum_name(name)
 
+        if self.emit_mode is StringEnumEmitMode.SOURCE_ENUM_ALIAS:
+            builder.ensure(
+                len(self.source_enums) == 1,
+                "source enum alias must reference one StringEnum",
+            )
+            source_enum = self.source_enums[0]
+            assert isinstance(source_enum, SpecTypeDefnStringEnum)
+            self.alias_source_enum = source_enum
+            builder.ensure(
+                self.values == source_enum.values,
+                "source enum alias must preserve all source values",
+            )
+            builder.ensure(
+                data_values is None,
+                "source enum alias cannot define local values",
+            )
+            builder.ensure(
+                self.sql_type_name is None,
+                "source enum alias cannot define a SQL type",
+            )
+
     def get_referenced_types(self) -> list[SpecType]:
         return self.source_enums
 
 
+SpecTypeDefnVariant = (
+    SpecTypeDefnAlias
+    | SpecTypeDefnExternal
+    | SpecTypeDefnNewType
+    | SpecTypeDefnObject
+    | SpecTypeDefnStringEnum
+    | SpecTypeDefnUnion
+)
+
+
 TOKEN_ENDPOINT = "$endpoint"
 TOKEN_EMIT_IO_TS = "$emit_io_ts"
 TOKEN_EMIT_TYPE_INFO = "$emit_type_info"
@@ -1171,6 +1236,7 @@ def parse_endpoint_specific_path(
 
 class SpecEndpoint:
     method: RouteMethod
+    alternate_methods: list[RouteMethod]
     data_loader: bool
     is_sdk: EndpointEmitType
     stability_level: StabilityLevel | None
@@ -1199,6 +1265,7 @@ class SpecEndpoint:
             data,
             [
                 "method",
+                "alternate_methods",
                 "path",
                 "data_loader",
                 "deprecated",
@@ -1219,6 +1286,26 @@ class SpecEndpoint:
         )
         self.method = RouteMethod(data["method"])
 
+        alternate_methods_raw = data.get("alternate_methods", [])
+        assert isinstance(alternate_methods_raw, list)
+        self.alternate_methods = [
+            RouteMethod(alternate_method) for alternate_method in alternate_methods_raw
+        ]
+        assert self.method not in self.alternate_methods, (
+            "alternate-methods-must-not-repeat-method"
+        )
+        assert len(set(self.alternate_methods)) == len(self.alternate_methods), (
+            "alternate-methods-must-be-unique"
+        )
+        if self.alternate_methods:
+            assert self.method == RouteMethod.get, (
+                "alternate-methods-require-get-primary-method"
+            )
+            assert all(
+                alternate_method == RouteMethod.post
+                for alternate_method in self.alternate_methods
+            ), "alternate-methods-must-be-post"
+
         data_loader = data.get("data_loader", False)
         assert isinstance(data_loader, bool)
         self.data_loader = data_loader
@@ -1446,7 +1533,7 @@ class SpecNamespace:
         self,
         name: str,
     ):
-        self.types: dict[str, SpecTypeDefn] = {}
+        self.types: dict[str, SpecTypeDefnVariant] = {}
         self.constants: dict[str, SpecConstant] = {}
         self.endpoint: SpecEndpoint | None = None
         self.emit_io_ts = False
@@ -1544,7 +1631,7 @@ class SpecNamespace:
             assert name not in self.types, f"{name} is duplicate"
             defn_type = defn.get("type")
             assert isinstance(defn_type, str), f"{name} requires a string type"
-            spec_type: SpecTypeDefn
+            spec_type: SpecTypeDefnVariant
             named_parameters = (
                 [
                     parameter.name
@@ -1775,13 +1862,14 @@ class SpecBuilder:
             raise BuilderError()
 
     def ensure_python_prepart_function(
-        self, *, namespace_name: str, function_name: str, option_name: str
+        self, *, namespace: SpecNamespace, function_name: str, option_name: str
     ) -> None:
-        python_prepart = self.preparts["python"].get(namespace_name, "")
+        namespace_key = ".".join(namespace.path)
+        python_prepart = self.preparts["python"].get(namespace_key, "")
         def_prefix = f"def {function_name}"
         self.ensure(
             f"{def_prefix}(" in python_prepart or f"{def_prefix}[" in python_prepart,
-            f"{option_name}: the {namespace_name} python prepart file must define {function_name}",
+            f"{option_name}: the {namespace.name} python prepart file must define {function_name}",
         )
 
     def prescan(self, namespace_path: str, data: RawDict) -> None:

pkgs/type_spec/builder_types.py

@@ -7,9 +7,3 @@ class CrossOutputPaths:
     typescript_types_output: str
     typescript_routes_output_by_endpoint: dict[str, str]
     typespec_files_input: list[str]
-
-
-@dataclass(kw_only=True, frozen=True)
-class PythonParseFallback:
-    legacy_property: str
-    convert: str

pkgs/type_spec/emit_open_api.py

@@ -4,6 +4,7 @@ Generates an OpenAPI specification based on the type_spec definitions
 WORK-IN-PROGRESS, DON'T USE!
 """
 
+import copy
 import dataclasses
 import json
 import re
@@ -248,12 +249,12 @@ def _emit_endpoint_parameter_examples(
 
 
 def _emit_endpoint_parameters(
-    endpoint: EmitOpenAPIEndpoint,
+    method: str,
     argument_type: OpenAPIType | None,
     examples: list[EmitOpenAPIEndpointExample],
 ) -> DictApiSchema:
     if (
-        endpoint.method.lower() not in _QUERY_PARM_METHODS
+        method.lower() not in _QUERY_PARM_METHODS
         or argument_type is None
         or _is_empty_object_type(argument_type)
     ):
@@ -307,12 +308,12 @@ def _emit_stability_level(
 
 
 def _emit_endpoint_request_body(
-    endpoint: EmitOpenAPIEndpoint,
+    method: str,
     arguments_type: OpenAPIType | None,
     examples: list[EmitOpenAPIEndpointExample],
 ) -> DictApiSchema:
     if (
-        endpoint.method.lower() not in _REQUEST_BODY_METHODS
+        method.lower() not in _REQUEST_BODY_METHODS
         or arguments_type is None
         or _is_empty_object_type(arguments_type)
     ):
@@ -406,6 +407,40 @@ def _emit_endpoint_description(
     return {"description": full_description}
 
 
+def _emit_endpoint_operation(
+    *,
+    endpoint: EmitOpenAPIEndpoint,
+    method: str,
+    argument_type: OpenAPIType | None,
+) -> DictApiSchema:
+    return (
+        {
+            "tags": endpoint.tags,
+            "summary": endpoint.summary,
+        }
+        | _emit_endpoint_deprecated(endpoint.deprecated)
+        | _emit_endpoint_description(
+            endpoint.description, endpoint.guides, endpoint.stability_level
+        )
+        | _emit_stability_level(endpoint.stability_level)
+        | _emit_endpoint_parameters(method, argument_type, endpoint.examples)
+        | _emit_endpoint_request_body(method, argument_type, endpoint.examples)
+        | {
+            "responses": {
+                "200": {
+                    "description": "OK",
+                    "content": {
+                        "application/json": {
+                            "schema": {"$ref": "#/components/schema/Data"}
+                        }
+                        | _emit_endpoint_response_examples(endpoint.examples)
+                    },
+                }
+            },
+        }
+    )
+
+
 def _emit_namespace(
     gctx: EmitOpenAPIGlobalContext,
     ctx: EmitOpenAPIContext,
@@ -432,36 +467,14 @@ def _emit_namespace(
     if ctx.endpoint is not None:
         endpoint = ctx.endpoint
         argument_type = ctx.types.get(ARGUMENTS_TYPE_NAME)
-        oa_endpoint = dict()
-        oa_endpoint[endpoint.method] = (
-            {
-                "tags": endpoint.tags,
-                "summary": endpoint.summary,
-            }
-            | _emit_endpoint_deprecated(endpoint.deprecated)
-            | _emit_endpoint_description(
-                endpoint.description, ctx.endpoint.guides, endpoint.stability_level
-            )
-            | _emit_stability_level(endpoint.stability_level)
-            | _emit_endpoint_parameters(endpoint, argument_type, ctx.endpoint.examples)
-            | _emit_endpoint_request_body(
-                endpoint, argument_type, ctx.endpoint.examples
+        oa_components["endpoint"] = {
+            method: copy.deepcopy(
+                _emit_endpoint_operation(
+                    endpoint=endpoint, method=method, argument_type=argument_type
+                )
             )
-            | {
-                "responses": {
-                    "200": {
-                        "description": "OK",
-                        "content": {
-                            "application/json": {
-                                "schema": {"$ref": "#/components/schema/Data"}
-                            }
-                            | _emit_endpoint_response_examples(ctx.endpoint.examples)
-                        },
-                    }
-                },
-            }
-        )
-        oa_components["endpoint"] = oa_endpoint
+            for method in [endpoint.method, *endpoint.alternate_methods]
+        }
 
     types = ctx.types
     if ctx.endpoint is not None:
@@ -682,6 +695,10 @@ def _emit_endpoint(
 
     ctx.endpoint = EmitOpenAPIEndpoint(
         method=namespace.endpoint.method.lower(),
+        alternate_methods=[
+            alternate_method.lower()
+            for alternate_method in namespace.endpoint.alternate_methods
+        ],
         tags=[tag_name],
         summary=f"{'/'.join(namespace.path[path_cutoff:])}",
         description=description,

pkgs/type_spec/emit_open_api_util.py

@@ -79,6 +79,7 @@ EmitOpenAPIStabilityLevel = builder.StabilityLevel
 @dataclass
 class EmitOpenAPIEndpoint:
     method: str
+    alternate_methods: list[str]
     tags: list[str]
     summary: str
     description: str