UncountablePythonSDK 0.0.73__py3-none-any.whl → 0.0.75__py3-none-any.whl

{UncountablePythonSDK-0.0.73.dist-info → UncountablePythonSDK-0.0.75.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: UncountablePythonSDK
-Version: 0.0.73
+Version: 0.0.75
 Summary: Uncountable SDK
 Project-URL: Homepage, https://github.com/uncountableinc/uncountable-python-sdk
 Project-URL: Repository, https://github.com/uncountableinc/uncountable-python-sdk.git

{UncountablePythonSDK-0.0.73.dist-info → UncountablePythonSDK-0.0.75.dist-info}/RECORD

@@ -26,10 +26,10 @@ examples/integration-server/jobs/materials_auto/example_cron.py,sha256=7VVQ-UJsq
 examples/integration-server/jobs/materials_auto/profile.yaml,sha256=MiqT9AHWoFz-rcpAHfiFTXuCP-18DaFipUaceati0-0,365
 pkgs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pkgs/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pkgs/argument_parser/__init__.py,sha256=CsQ6QoPKSLLRVl-z6URAmPkiUL9ZPZoV4rJHgy_-RjA,385
+pkgs/argument_parser/__init__.py,sha256=JRfZkC0-q6axr8F5_TKrjSprJ7d7chfcPvf-iMQqFg0,447
 pkgs/argument_parser/_is_enum.py,sha256=Gw6jJa8nBwYGqXwwCZbSnWL8Rvr5alkg5lSVAqXtOZM,257
 pkgs/argument_parser/_is_namedtuple.py,sha256=Rjc1bKanIPPogl3qG5JPBxglG1TqWYOo1nxxhBASQWY,265
-pkgs/argument_parser/argument_parser.py,sha256=uI_fSs7XmiQf9kt4ztWqqF9v8w4dZmQRy3tssPYVRDE,17330
+pkgs/argument_parser/argument_parser.py,sha256=Z8lR_2L_N0zuxdOsK91D_9mjlsCcR_FJwtCLIfJz5oI,17713
 pkgs/argument_parser/case_convert.py,sha256=NuJLJUJRbyVb6_Slen4uqaStEHbcOS1d-hBBfDrrw-c,605
 pkgs/filesystem_utils/__init__.py,sha256=NSsQrUCoGISBCqCCyq6_583sYHTVEQeDjDO8hvZn3ag,1261
 pkgs/filesystem_utils/_gdrive_session.py,sha256=GJuZYJq1W4QQ_7OLvZIMK99FgRq8FxJHg6cMUx9prtA,11077
@@ -41,7 +41,7 @@ pkgs/filesystem_utils/filesystem_session.py,sha256=BQ2Go8Mu9-GcnaWh2Pm4x7ugLVsre
 pkgs/serialization/__init__.py,sha256=LifasRW0a50A3qRFmo2bf3FQ6TXhZWOTz2-CVTgPjcQ,753
 pkgs/serialization/missing_sentry.py,sha256=aM_9KxbCk9dVvXvcOKgkIQBqFWvLhv8QlIUCiuFEXMo,806
 pkgs/serialization/opaque_key.py,sha256=FIfXEE0DA1U8R_taFbQ1RCoTSgehrPjP06-qvo-GeNQ,177
-pkgs/serialization/serial_class.py,sha256=tD9kNotc6BOzkGi8yew89Wp_fSIA3a0VW7I8cSS_jHI,5607
+pkgs/serialization/serial_class.py,sha256=D7vSnfJw4rWEDFbDd07pxgzyfTFZT5SKeQEv4C1c4H0,6057
 pkgs/serialization/serial_union.py,sha256=xpdeqCrRd0sNCaUwBQRzje6V40ndCbJpZrLX2K0d5xo,2741
 pkgs/serialization/yaml.py,sha256=yoJtu7_ixnJV6uTxA_U1PpK5F_ixT08AKVh5ocyYwXM,1466
 pkgs/serialization_util/__init__.py,sha256=MVKqHTUl2YnWZAFG9xCxu1SgmkQ5xPofrAGlYg6h7rI,330
@@ -52,25 +52,25 @@ pkgs/strenum_compat/__init__.py,sha256=wXRFeNvBm8RU6dy1PFJ5sRLgUIEeH_DVR95Sv5qpG
 pkgs/strenum_compat/strenum_compat.py,sha256=uOUAgpYTjHs1MX8dG81jRlyTkt3KNbkV_25zp7xTX2s,36
 pkgs/type_spec/__init__.py,sha256=h5DmJTca4QVV10sZR1x0-MlkZfuGYDfapR3zHvXfzto,19
 pkgs/type_spec/__main__.py,sha256=5bJaX9Y_-FavP0qwzhk-z-V97UY7uaezJTa1zhO_HHQ,1048
-pkgs/type_spec/builder.py,sha256=EUMEc0Mj0p9vb5QYojpe7Eu1UQB0Mg0p3oGzqTrtWZA,46888
+pkgs/type_spec/builder.py,sha256=nuHdVNOmwbHbHV5_8nqtsrxOfzIII6jcQO7eLOljT4c,48856
 pkgs/type_spec/config.py,sha256=ZUmPWCzTwjesAqlqeL1_E_yoIUZE_8g0kI2yXtbU0Zc,4811
 pkgs/type_spec/emit_io_ts.py,sha256=U03sQBpgRqYOaMKrPCRnYb70YboiCgaZfseCXSzW5NY,5707
 pkgs/type_spec/emit_open_api.py,sha256=5a0iAHBbgFD4wfKuyjPvxCYYHNTjKxEHA0aYjMGSqe4,24596
 pkgs/type_spec/emit_open_api_util.py,sha256=x4GCiZSGdypJ9Qtm6I5W_3UvwdJyMs8_OGhJ8_THznA,2401
-pkgs/type_spec/emit_python.py,sha256=u09ueuF5ypUsyNkxnBFGsS8tivVsjvmUCkPLM_RIask,47466
-pkgs/type_spec/emit_typescript.py,sha256=Tv8EbXBQewZN9q3zRKfTy9lWwElBmIV6fprIjA4RmJQ,18010
-pkgs/type_spec/emit_typescript_util.py,sha256=sR7ys3Ilnh6SQiXJbfYk4pxfOu0bDjbUFTEYEW-ud6c,863
+pkgs/type_spec/emit_python.py,sha256=eBct7PMYgcv35POo2JU089lLggPrgLfTOrKpqAukn1E,47370
+pkgs/type_spec/emit_typescript.py,sha256=PL1h2UvTp1PRMkTXH893ZYS3cPUrrupjnLg_9ndZGDQ,8838
+pkgs/type_spec/emit_typescript_util.py,sha256=e2rGSs9OTD-iXwcHfU4V9E35jwMc5qVshhOKMknGrJ8,10319
 pkgs/type_spec/load_types.py,sha256=vO8VLI7aTKzzHQIla-WO-5Z_mfTuwUqH4ZSKN9E9n5U,3688
 pkgs/type_spec/open_api_util.py,sha256=IGh-_snGPST_P_8FdYtO8MTEa9PUxRW6Rzg9X9EgQik,7114
 pkgs/type_spec/test.py,sha256=4ueujBq-pEgnX3Z69HyPmD-bullFXmpixcpVzfOkhP4,489
-pkgs/type_spec/util.py,sha256=6m6MPfY-SwjyZf2FWQKclswWB5o7gcdd-3tdpViPYOQ,4844
+pkgs/type_spec/util.py,sha256=79SLJsSPVnBe2_3CTF6J-7-QD9nRr6o8MKvfjyx53eI,4864
 pkgs/type_spec/actions_registry/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pkgs/type_spec/actions_registry/__main__.py,sha256=JGwKxcAmrQdbpVR2vwknoimN1Q-r5h4SADw1cYLYzgk,4331
 pkgs/type_spec/actions_registry/emit_typescript.py,sha256=Z1ZM4zOw26tvLspvW6Emg79-jxjhNBse-8yaionbmeo,6066
 pkgs/type_spec/parts/base.py.prepart,sha256=wGNoDyQnLolHRZGRwHQX5TrPfKnu558NXCocYvqyroc,2174
 pkgs/type_spec/parts/base.ts.prepart,sha256=2FJJvpg2olCcavxj0nbYWdwKl6KeScour2JjSvN42l8,1001
 pkgs/type_spec/type_info/__main__.py,sha256=pmVjVqXyVh8vKTNCTFgz80Sg74C5BKToP3E6GS-X_So,857
-pkgs/type_spec/type_info/emit_type_info.py,sha256=1R1ygKbGBIrKDCh3NDiBB6w9ofRCoCjujhHZx9A4_Wc,13289
+pkgs/type_spec/type_info/emit_type_info.py,sha256=C4Rq5z22c3IJTyQriNkQWgGV7I3ZgTDjwKm_JM_sOYI,13362
 pkgs/type_spec/value_spec/__init__.py,sha256=Z-grlcZtxAfEXhPHsK0nD7PFLGsv4eqvunaPN7_TA84,83
 pkgs/type_spec/value_spec/__main__.py,sha256=6bzP85p_Cm4bPp5tXz8D_4p64wMn5SKsXC7SqSZquYc,8318
 pkgs/type_spec/value_spec/convert_type.py,sha256=Tg5YsYOwvmf_EqbCAtCmqy3-dud8OwdbEOzAaRN7cCs,2286
@@ -105,7 +105,7 @@ uncountable/integration/queue_runner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeu
 uncountable/integration/queue_runner/job_scheduler.py,sha256=n6bM6ZqVOPD0PoJuZV5Y5tuhmw2gI-_p6JbnVlK42uI,5016
 uncountable/integration/queue_runner/queue_runner.py,sha256=0BmYu5zHdothTevGsB-nXg6MBd1UD-WkP3h1WCKMdQg,710
 uncountable/integration/queue_runner/types.py,sha256=8qTq29BTSa5rmW6CBlBntP0pNIiDcwu1wHa78pjroS0,219
-uncountable/integration/queue_runner/worker.py,sha256=wS_Mv12MtG9ULz2K4nUdivUAxJdZmd6B6GEUhqysG2A,4403
+uncountable/integration/queue_runner/worker.py,sha256=Bwp7_OD4AughY01QQtZxlmZ5yrDmDk1GuijH09xhUkk,4455
 uncountable/integration/queue_runner/command_server/__init__.py,sha256=gQPVILGpWzCr2i5GJyoqna7AOSFvtn4tav69gB78mTQ,571
 uncountable/integration/queue_runner/command_server/command_client.py,sha256=DJb0TUVFkiiLBEQzHSN94sTRnuEbutNEgdN39XmnOXI,2046
 uncountable/integration/queue_runner/command_server/command_server.py,sha256=yyXryhiEC2eGS0yFElLGsVzSKwOuYvj-zp22jQorkv0,2138
@@ -124,7 +124,7 @@ uncountable/integration/secret_retrieval/retrieve_secret.py,sha256=eoPWbkUtCn_63
 uncountable/integration/webhook_server/entrypoint.py,sha256=hgbEtdVo3QU3odlHSygxmrsxR9g7rgU0yKt-o9nVAHE,5686
 uncountable/types/__init__.py,sha256=KSsSEBnGhn88NPex5q9MZtY4kj8PRqVTbaKtko4hxUU,8561
 uncountable/types/async_batch.py,sha256=_OhT25_dEVts_z_n1kqfJH3xlZg3btLqR6TNkfFLlXE,609
-uncountable/types/async_batch_processor.py,sha256=obVzN-PcYLV2pHScszfCGjSq6-Xc34WM1ysx6Fv6tZk,11293
+uncountable/types/async_batch_processor.py,sha256=esKBP56RiRH-VjAFBr8wgfcgKsRkUfiLBmQmYGx4XXY,11462
 uncountable/types/async_batch_t.py,sha256=CZ-rltFUiKVowvL5BhMfWaFxgf-Z0KPsghvjsg-PweY,2493
 uncountable/types/base.py,sha256=xVSjWvA_fUUnkCg83EjoYEFvAfmskinKFMeYFOxNc9E,359
 uncountable/types/base_t.py,sha256=XXjZXexx0xWFUxMMhW8i9nIL6n8dsZVsHwdgnhZ0zJ4,2714
@@ -132,13 +132,13 @@ uncountable/types/calculations.py,sha256=FFO_D3BbKoGDZnqWvTKpW4KF359i2vrKjpdFCLY
 uncountable/types/calculations_t.py,sha256=157qD0VqijD5kNDF5BRsfGli3WaPGnNjoo2o2CPX-Ik,669
 uncountable/types/chemical_structure.py,sha256=E-LnikTFDoVQ1b2zKaVUIO_PAKm-7aZZYJi8I8SDSic,302
 uncountable/types/chemical_structure_t.py,sha256=zDJ6WkeT3YwWZRZT21znQn2ZYelv3L7yv7kJiGoNZCw,824
-uncountable/types/client_base.py,sha256=KfeZ_PrfHO0U-4cUDXA9Kfy7slHfuxsANakKQJaFHV8,67320
+uncountable/types/client_base.py,sha256=qTifyQNBOwlspjWccQXg4gOhuwyQDy5z77rlreDynBU,67603
 uncountable/types/client_config.py,sha256=4h5Liko9uKCo9_0gdbPhoK6Jr2Kv7tioLiQ8iKeq-_4,301
 uncountable/types/client_config_t.py,sha256=6dStfR0IEHiPW8f9_aF3DD_tHmXXw2rEVrgpebzq8Fg,747
 uncountable/types/curves.py,sha256=W6uMpG5SyW1MS82szNpxkFEn1MnxNpBFyFbQb2Ysfng,366
 uncountable/types/curves_t.py,sha256=lKhRM-2cZ_sFaW7pa_I_Ipz_pJhm3_yTFehRXI79pKk,1416
 uncountable/types/entity.py,sha256=3XhLteFDRDZvHejDuYh-KvB65hpwrBygljFfiUcOAM8,315
-uncountable/types/entity_t.py,sha256=2F6zIxffc6l0hgjPtNUr3X0LKC4lxRMJZCT6T788GlI,14929
+uncountable/types/entity_t.py,sha256=8OkFVgvrItdA1ysyWB21mLL85JTPdcdzAmb6CNBUVI0,15003
 uncountable/types/experiment_groups.py,sha256=_0OXcPzSAbkE-rfKt5tPx178YJ4pcEKZvrCxUHgDnvw,309
 uncountable/types/experiment_groups_t.py,sha256=qEs8YW0eJOJ_sCOObT5v9QRx9wsjLYpJqJhCJXa-vNA,721
 uncountable/types/field_values.py,sha256=uuIWX-xmfvcinYPdfkWJeb56zzQY01mc9rmotMPMh24,503
@@ -204,8 +204,8 @@ uncountable/types/api/batch/execute_batch_load_async.py,sha256=j5a5dk0_lTJ-YslrB
 uncountable/types/api/chemical/__init__.py,sha256=gCgbynxG3jA8FQHzercKtrHKHkiIKr8APdZYUniAor8,55
 uncountable/types/api/chemical/convert_chemical_formats.py,sha256=xLpma1W1O9MzgxM4CCl5GPnpj3dpqRHhKcXr3b_ToAo,1589
 uncountable/types/api/entity/__init__.py,sha256=gCgbynxG3jA8FQHzercKtrHKHkiIKr8APdZYUniAor8,55
-uncountable/types/api/entity/create_entities.py,sha256=3zBPO3_CM9fU2R1EFWQcFcXxCVCNNU2NIsnJLYnojzI,2219
-uncountable/types/api/entity/create_entity.py,sha256=elMRdi8VT7CTrPhypQsL9P5gvCLlk5_D_1CUxulnXzA,2331
+uncountable/types/api/entity/create_entities.py,sha256=hG81k_nKD4orTtb5jKIkCarkSbUa3fXAxES6IZVkhL0,2276
+uncountable/types/api/entity/create_entity.py,sha256=BV99ZfkxPfMEGD0YvuMizK25Nll0o0GFho8_Mzb0Clk,2388
 uncountable/types/api/entity/get_entities_data.py,sha256=gTEZ7Z7T-DWP8BZPNDF4c__EHtf9kAb1sGtHmiGOgnM,1454
 uncountable/types/api/entity/list_entities.py,sha256=ykbdq4DD31uiRz4i8LH-8LLeA2Lpp_5fWfb5fdyx248,2000
 uncountable/types/api/entity/lock_entity.py,sha256=mMZx2tWOtuYg0sIftdPsFWgZO5LCav2ubqTw97dCtDU,1197
@@ -276,8 +276,8 @@ uncountable/types/api/recipes/unlock_recipes.py,sha256=RaC5N5rz6f3FAIaQM3NgLuXEM
 uncountable/types/api/triggers/__init__.py,sha256=gCgbynxG3jA8FQHzercKtrHKHkiIKr8APdZYUniAor8,55
 uncountable/types/api/triggers/run_trigger.py,sha256=-oZgPyn43xEKSCs81DVNzwaYMCdRJxbM9GY6fsqKwf4,1090
 uncountable/types/api/uploader/__init__.py,sha256=gCgbynxG3jA8FQHzercKtrHKHkiIKr8APdZYUniAor8,55
-uncountable/types/api/uploader/invoke_uploader.py,sha256=EMtTBwcFXDde5Y2LpubyjAcXcDpBp8yT4HAPR4o95JE,1230
-UncountablePythonSDK-0.0.73.dist-info/METADATA,sha256=P9sk2jp7gGaHwQv7hTMwFDdszfZDNnlYOes3gpcMPIM,2051
-UncountablePythonSDK-0.0.73.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-UncountablePythonSDK-0.0.73.dist-info/top_level.txt,sha256=1UVGjAU-6hJY9qw2iJ7nCBeEwZ793AEN5ZfKX9A1uj4,31
-UncountablePythonSDK-0.0.73.dist-info/RECORD,,
+uncountable/types/api/uploader/invoke_uploader.py,sha256=6mwVG136oLp9JcbB2I-kZnrcm3aeZzYZB-SFjEImY2o,1314
+UncountablePythonSDK-0.0.75.dist-info/METADATA,sha256=__fXg5O7uTKPPzAFToY3pOV8EHnNl6uX7UWCNat0E8Y,2051
+UncountablePythonSDK-0.0.75.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+UncountablePythonSDK-0.0.75.dist-info/top_level.txt,sha256=1UVGjAU-6hJY9qw2iJ7nCBeEwZ793AEN5ZfKX9A1uj4,31
+UncountablePythonSDK-0.0.75.dist-info/RECORD,,

{UncountablePythonSDK-0.0.73.dist-info → UncountablePythonSDK-0.0.75.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.1.0)
+Generator: setuptools (75.3.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

pkgs/argument_parser/__init__.py

@@ -1,4 +1,5 @@
 from .argument_parser import CachedParser as CachedParser
+from .argument_parser import ParserFunction as ParserFunction
 from .argument_parser import ParserOptions as ParserOptions
 from .argument_parser import build_parser as build_parser
 from .case_convert import camel_to_snake_case as camel_to_snake_case

pkgs/argument_parser/argument_parser.py

@@ -1,4 +1,5 @@
 import dataclasses
+import math
 import types
 import typing
 from collections import defaultdict
@@ -299,7 +300,18 @@ def _build_parser_inner(
 
         return parse_str
 
-    if parsed_type in (float, dict, bool, Decimal) or is_string_enum_class(parsed_type):
+    if parsed_type in (float, Decimal):
+
+        def parse_as_numeric_type(value: typing.Any) -> T:
+            numeric_value: Decimal | float = parsed_type(value)  # type: ignore
+            if math.isnan(numeric_value):
+                raise ValueError(f"Invalid numeric value: {numeric_value}")
+
+            return numeric_value  # type: ignore
+
+        return parse_as_numeric_type
+
+    if parsed_type in (dict, bool) or is_string_enum_class(parsed_type):
         return lambda value: parsed_type(value)  # type: ignore
 
     if parsed_type is MissingSentryType:

pkgs/serialization/serial_class.py

@@ -15,6 +15,10 @@ class _SerialClassData:
     to_string_values: set[str] = dataclasses.field(default_factory=set)
     parse_require: set[str] = dataclasses.field(default_factory=set)
     named_type_path: Optional[str] = None
+    # Tracks if this data was provided as a decorator to the type.
+    # This is used to track "proper types" which are appropriate
+    # for serialization and/or dynamic discovery
+    from_decorator: bool = False
 
 
 EMPTY_SERIAL_CLASS_DATA = _SerialClassData()
@@ -58,6 +62,7 @@ def serial_class(
             to_string_values=to_string_values or set(),
             parse_require=parse_require or set(),
             named_type_path=named_type_path,
+            from_decorator=True,
         )
         return orig_class
 
@@ -83,6 +88,14 @@ class SerialClassDataInspector:
     def has_parse_require(self, key: str) -> bool:
         return key in self.current.parse_require
 
+    @property
+    def from_decorator(self) -> bool:
+        return self.current.from_decorator
+
+    @property
+    def named_type_path(self) -> Optional[str]:
+        return self.current.named_type_path
+
 
 def _get_merged_serial_class_data(type_class: type[Any]) -> _SerialClassData | None:
     base_class_data = (

pkgs/type_spec/builder.py

@@ -307,6 +307,9 @@ class SpecTypeDefn(SpecType):
     def is_base_type(self, type_: BaseTypeName) -> bool:
         return self.is_base and self.name == type_
 
+    def can_process(self, builder: SpecBuilder, data: RawDict) -> bool:
+        return True
+
     @abc.abstractmethod
     def process(self, builder: SpecBuilder, data: RawDict) -> None: ...
 
@@ -666,15 +669,30 @@ class SpecTypeDefnStringEnum(SpecTypeDefn):
         self.desc: str | None = None
         self.sql_type_name: Optional[str] = None
         self.emit_id_source = False
+        self.source_enums: list[SpecType] = []
+
+    def can_process(self, builder: SpecBuilder, data: dict[Any, Any]) -> bool:
+        source_enums = data.get("source_enums")
+        try:
+            for sub_type_str in source_enums or []:
+                sub_type = builder.parse_type(self.namespace, sub_type_str)
+                assert isinstance(sub_type, SpecTypeDefnStringEnum)
+                assert len(sub_type.values) > 0
+        except AssertionError:
+            return False
+        return super().can_process(builder, data)
 
     def process(self, builder: SpecBuilder, data: RawDict) -> None:
         super().base_process(
-            builder, data, ["type", "desc", "values", "name_case", "sql", "emit"]
+            builder,
+            data,
+            ["type", "desc", "values", "name_case", "sql", "emit", "source_enums"],
         )
         self.name_case = NameCase(data.get("name_case", "convert"))
         self.values = {}
-        data_values = data["values"]
+        data_values = data.get("values")
         self.desc = data.get("desc", None)
+        source_enums = data.get("source_enums", None)
         if isinstance(data_values, dict):
             for name, value in data_values.items():
                 builder.push_where(name)
@@ -717,7 +735,8 @@ class SpecTypeDefnStringEnum(SpecTypeDefn):
                     )
                 self.values[value] = StringEnumEntry(name=value, value=value)
         else:
-            raise Exception("unsupported values type")
+            if source_enums is None or data_values is not None:
+                raise Exception("unsupported values type")
 
         sql_data = data.get("sql")
         if sql_data is not None:
@@ -739,9 +758,18 @@ class SpecTypeDefnStringEnum(SpecTypeDefn):
                 builder.ensure(
                     entry.label is not None, f"need-label-for-id-source:{entry.name}"
                 )
+        for sub_type_str in source_enums or []:
+            sub_type = builder.parse_type(self.namespace, sub_type_str)
+            self.source_enums.append(sub_type)
+
+        for sub_type in self.source_enums:
+            builder.push_where(sub_type.name)
+            if isinstance(sub_type, SpecTypeDefnStringEnum):
+                self.values.update(sub_type.values)
+            builder.pop_where()
 
     def get_referenced_types(self) -> list[SpecType]:
-        return []
+        return self.source_enums
 
 
 TOKEN_ENDPOINT = "$endpoint"
@@ -1122,28 +1150,41 @@ class SpecNamespace:
         Complete the definition of each type.
         """
         builder.push_where(self.name)
-        for full_name, defn in data.items():
-            parsed_name = parse_type_str(full_name)[0]
-            name = parsed_name.name
+        items_to_process: list[NameDataPair] = [
+            NameDataPair(full_name=full_name, data=defn)
+            for full_name, defn in data.items()
+        ]
+        while len(items_to_process) > 0:
+            deferred_items: list[NameDataPair] = []
+            for item in items_to_process:
+                full_name = item.full_name
+                defn = item.data
+                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]:
+                    continue
 
-            if name in [TOKEN_EMIT_IO_TS, TOKEN_EMIT_TYPE_INFO, TOKEN_IMPORT]:
-                continue
+                builder.push_where(name)
 
-            builder.push_where(name)
+                if "value" in defn:
+                    spec_constant = self.constants[name]
+                    spec_constant.process(builder, defn)
 
-            if "value" in defn:
-                spec_constant = self.constants[name]
-                spec_constant.process(builder, defn)
+                elif name == TOKEN_ENDPOINT:
+                    assert self.endpoint
+                    self.endpoint.process(builder, defn)
 
-            elif name == TOKEN_ENDPOINT:
-                assert self.endpoint
-                self.endpoint.process(builder, defn)
-
-            else:
-                spec_type = self.types[name]
-                spec_type.process(builder, defn)
+                else:
+                    spec_type = self.types[name]
+                    if spec_type.can_process(builder, defn):
+                        spec_type.process(builder, defn)
+                    else:
+                        deferred_items.append(item)
 
-            builder.pop_where()
+                builder.pop_where()
+            assert len(deferred_items) < len(items_to_process)
+            items_to_process = [deferred for deferred in deferred_items]
 
         builder.pop_where()
 
@@ -1158,6 +1199,12 @@ class NamespaceDataPair:
     data: RawDict
 
 
+@dataclass(kw_only=True)
+class NameDataPair:
+    full_name: str
+    data: RawDict
+
+
 class SpecBuilder:
     def __init__(self, *, api_endpoints: dict[str, str], top_namespace: str) -> None:
         self.top_namespace = top_namespace

pkgs/type_spec/emit_python.py

@@ -44,7 +44,6 @@ class TrackingContext:
     use_enum: bool = False
     use_serial_string_enum: bool = False
     use_dataclass: bool = False
-    use_serial_class: bool = False
     use_serial_union: bool = False
     use_missing: bool = False
     use_opaque_key: bool = False
@@ -223,7 +222,6 @@ def _emit_types_imports(*, out: io.StringIO, ctx: Context) -> None:
         out.write("from pkgs.strenum_compat import StrEnum\n")
     if ctx.use_dataclass:
         out.write("import dataclasses\n")
-    if ctx.use_serial_class:
         out.write("from pkgs.serialization import serial_class\n")
     if ctx.use_serial_union:
         out.write("from pkgs.serialization import serial_union_annotation\n")
@@ -834,7 +832,6 @@ def _emit_type(ctx: Context, stype: builder.SpecType) -> None:
     _emit_generic(ctx, stype.get_generic())
 
     # Emit serial_class decorator
-    ctx.use_serial_class = True
     ctx.out.write("@serial_class(\n")
     ctx.out.write(
         f"{INDENT}named_type_path={util.encode_common_string(_named_type_path(ctx, stype))},\n"

pkgs/type_spec/emit_typescript.py

@@ -1,82 +1,21 @@
 import io
 import os
-from typing import Any
 
 from . import builder, util
-from .builder import SpecTypeDefnObject
 from .config import TypeScriptConfig
 from .emit_io_ts import emit_type_io_ts
 from .emit_typescript_util import (
-    INDENT,
     MODIFY_NOTICE,
     EmitTypescriptContext,
+    emit_namespace_imports_ts,
+    emit_type_ts,
+    emit_value_ts,
+    resolve_namespace_name,
     resolve_namespace_ref,
-    ts_name,
     ts_type_name,
 )
 
 
-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_value(ctx: EmitTypescriptContext, stype: builder.SpecType, value: Any) -> 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(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(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]
-            return (
-                "{\n\t"
-                + ",\n\t".join(
-                    "["
-                    + _emit_value(ctx, key_type, dkey)
-                    + "]: "
-                    + _emit_value(ctx, value_type, dvalue)
-                    for dkey, dvalue in value.items()
-                )
-                + "\n}"
-            )
-
-        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(ctx, sub_type, value)
-
-    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)
-
-
 def emit_typescript(builder: builder.SpecBuilder, config: TypeScriptConfig) -> None:
     _emit_types(builder, config)
     _emit_id_source(builder, config)
@@ -90,13 +29,11 @@ def _emit_types(builder: builder.SpecBuilder, config: TypeScriptConfig) -> None:
 
     for namespace in sorted(
         builder.namespaces.values(),
-        key=lambda ns: _resolve_namespace_name(ns),
+        key=lambda ns: resolve_namespace_name(ns),
     ):
-        ctx = EmitTypescriptContext(
-            out=io.StringIO(), namespace=namespace, config=config
-        )
+        ctx = EmitTypescriptContext(out=io.StringIO(), namespace=namespace)
 
-        _emit_namespace(ctx, namespace)
+        _emit_namespace(ctx, config, namespace)
 
         prepart = builder.preparts["typescript"].get(namespace.name)
         part = builder.parts["typescript"].get(namespace.name)
@@ -123,16 +60,7 @@ def _emit_types(builder: builder.SpecBuilder, config: TypeScriptConfig) -> None:
             full.write(f"// === END section from {namespace.name}.ts.prepart ===\n")
             full.write("\n")
 
-        for ns in sorted(
-            ctx.namespaces,
-            key=lambda name: _resolve_namespace_name(name),
-        ):
-            import_as = resolve_namespace_ref(ns)
-            import_path = (
-                "./" if len(namespace.path) == 1 else "../" * (len(namespace.path) - 1)
-            )
-            import_from = f"{import_path}{_resolve_namespace_name(ns)}"
-            full.write(f'import * as {import_as} from "{import_from}"\n')  # noqa: E501
+        emit_namespace_imports_ts(ctx.namespaces, out=full, current_namespace=namespace)
         if namespace.emit_io_ts:
             full.write("import * as IO from 'io-ts';")
         full.write(ctx.out.getvalue())
@@ -152,7 +80,7 @@ def _emit_types(builder: builder.SpecBuilder, config: TypeScriptConfig) -> None:
 
         if len(namespace.path) == 1:
             index_out.write(
-                f"import * as {resolve_namespace_ref(namespace)} from './{_resolve_namespace_name(namespace)}'\n"
+                f"import * as {resolve_namespace_ref(namespace)} from './{resolve_namespace_name(namespace)}'\n"
             )  # noqa: E501
             index_out_end.write(f"export {{{resolve_namespace_ref(namespace)}}}\n")
 
@@ -164,23 +92,26 @@ def _emit_types(builder: builder.SpecBuilder, config: TypeScriptConfig) -> None:
 
 
 def _emit_namespace(
-    ctx: EmitTypescriptContext, namespace: builder.SpecNamespace
+    ctx: EmitTypescriptContext,
+    config: TypeScriptConfig,
+    namespace: builder.SpecNamespace,
 ) -> None:
     for stype in namespace.types.values():
         if namespace.emit_io_ts:
             emit_type_io_ts(ctx, stype, namespace.derive_types_from_io_ts)
         if not namespace.emit_io_ts or not namespace.derive_types_from_io_ts:
-            _emit_type(ctx, stype)
+            emit_type_ts(ctx, stype)
 
     for sconst in namespace.constants.values():
         _emit_constant(ctx, sconst)
 
     if namespace.endpoint is not None:
-        _emit_endpoint(ctx, namespace, namespace.endpoint)
+        _emit_endpoint(ctx, config, namespace, namespace.endpoint)
 
 
 def _emit_endpoint(
     ctx: EmitTypescriptContext,
+    config: TypeScriptConfig,
     namespace: builder.SpecNamespace,
     endpoint: builder.SpecEndpoint,
 ) -> None:
@@ -265,14 +196,12 @@ export const apiCall = {wrap_call}(
 )
 {data_loader_body}"""
 
-    output = f"{ctx.config.routes_output}/{"/".join(namespace.path)}.tsx"
+    output = f"{config.routes_output}/{"/".join(namespace.path)}.tsx"
     util.rewrite_file(output, tsx_api)
 
     # Hacky index support, until enough is migrated to regen entirely
     # Emits the import into the UI API index file
-    index_path = (
-        f"{ctx.config.routes_output}/{"/".join(namespace.path[0:-1])}/index.tsx"
-    )
+    index_path = f"{config.routes_output}/{"/".join(namespace.path[0:-1])}/index.tsx"
     api_name = f"Api{ts_type_name(namespace.path[0 - 1])}"
     if os.path.exists(index_path):
         with open(index_path) as index:
@@ -288,164 +217,14 @@ export const apiCall = {wrap_call}(
             index.write(f"export {{ {api_name} }}\n")
 
 
-def _emit_type(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(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, 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 _emit_constant(ctx: EmitTypescriptContext, sconst: builder.SpecConstant) -> None:
     ctx.out.write("\n\n")
     ctx.out.write(MODIFY_NOTICE)
-    value = _emit_value(ctx, sconst.value_type, sconst.value)
+    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")
 
 
-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",
-}
-
-
-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(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 _emit_id_source(builder: builder.SpecBuilder, config: TypeScriptConfig) -> None:
     id_source_output = config.id_source_output
     if id_source_output is None:

pkgs/type_spec/emit_typescript_util.py

@@ -1,17 +1,33 @@
 import io
+import typing
 from dataclasses import dataclass, field
 
 from . import builder, util
-from .config import TypeScriptConfig
 
 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)
@@ -30,3 +46,220 @@ def ts_name(name: str, name_case: builder.NameCase) -> str:
         return name
     bits = util.split_any_name(name)
     return "".join([bits[0], *[x.title() for x in bits[1:]]])
+
+
+def emit_value_ts(
+    ctx: EmitTypescriptContext, stype: builder.SpecType, value: typing.Any
+) -> 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]
+            return (
+                "{\n\t"
+                + ",\n\t".join(
+                    "["
+                    + emit_value_ts(ctx, key_type, dkey)
+                    + "]: "
+                    + emit_value_ts(ctx, value_type, dvalue)
+                    for dkey, dvalue in value.items()
+                )
+                + "\n}"
+            )
+
+        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)}"
+
+    raise Exception("invalid constant type", value, stype)
+
+
+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(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

pkgs/type_spec/type_info/emit_type_info.py

@@ -5,7 +5,7 @@ import io
 import json
 from typing import Any, Optional, Union, cast
 
-from main.base.types import data_t
+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 (
@@ -17,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
@@ -174,7 +174,7 @@ class InheritablePropertyParts:
 
     label: Optional[str] = None
     desc: Optional[str] = None
-    ext_info: Optional[data_t.ExtInfo] = None
+    ext_info: Optional[type_info_t.ExtInfo] = None
 
 
 def _extract_inheritable_property_parts(
@@ -201,7 +201,7 @@ def _extract_inheritable_property_parts(
     elif base_parts.ext_info is None:
         ext_info = local_ext_info
     else:
-        ext_info = data_t.ExtInfo(
+        ext_info = type_info_t.ExtInfo(
             **(local_ext_info.__dict__ | base_parts.ext_info.__dict__)
         )
 
@@ -214,7 +214,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:
     """
@@ -264,7 +264,7 @@ def _extract_and_validate_layout(
 
 def _validate_type_ext_info(
     stype: builder.SpecTypeDefnObject,
-) -> tuple[ExtInfoLayout | None, Optional[data_t.ExtInfo]]:
+) -> tuple[ExtInfoLayout | None, Optional[type_info_t.ExtInfo]]:
     ext_info = _parse_ext_info(stype.ext_info)
     if ext_info is None:
         return None, None
@@ -364,7 +364,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) -> Optional[type_info_t.ExtInfo]:
     if in_ext is None:
         return None
     assert isinstance(in_ext, dict)

pkgs/type_spec/util.py

@@ -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]:

uncountable/integration/queue_runner/worker.py

@@ -86,23 +86,23 @@ def run_queued_job(
             profile_metadata=job_details.profile_metadata,
             job_definition=job_details.job_definition,
         )
-        client = construct_uncountable_client(
-            profile_meta=job_details.profile_metadata, job_logger=job_logger
-        )
-        batch_processor = AsyncBatchProcessor(client=client)
+        try:
+            client = construct_uncountable_client(
+                profile_meta=job_details.profile_metadata, job_logger=job_logger
+            )
+            batch_processor = AsyncBatchProcessor(client=client)
 
-        payload = _resolve_queued_job_payload(queued_job)
+            payload = _resolve_queued_job_payload(queued_job)
 
-        args = JobArguments(
-            job_definition=job_details.job_definition,
-            client=client,
-            batch_processor=batch_processor,
-            profile_metadata=job_details.profile_metadata,
-            logger=job_logger,
-            payload=payload,
-        )
+            args = JobArguments(
+                job_definition=job_details.job_definition,
+                client=client,
+                batch_processor=batch_processor,
+                profile_metadata=job_details.profile_metadata,
+                logger=job_logger,
+                payload=payload,
+            )
 
-        try:
             return execute_job(
                 args=args,
                 profile_metadata=job_details.profile_metadata,

uncountable/types/api/entity/create_entities.py

@@ -41,7 +41,7 @@ class EntityToCreate:
 @dataclasses.dataclass(kw_only=True)
 class Arguments:
     definition_id: base_t.ObjectId
-    entity_type: typing.Union[typing.Literal[entity_t.EntityType.LAB_REQUEST], typing.Literal[entity_t.EntityType.APPROVAL], typing.Literal[entity_t.EntityType.CUSTOM_ENTITY], typing.Literal[entity_t.EntityType.INVENTORY_AMOUNT], typing.Literal[entity_t.EntityType.TASK], typing.Literal[entity_t.EntityType.PROJECT], typing.Literal[entity_t.EntityType.EQUIPMENT], typing.Literal[entity_t.EntityType.INV_LOCAL_LOCATIONS], typing.Literal[entity_t.EntityType.FIELD_OPTION_SET], typing.Literal[entity_t.EntityType.WEBHOOK], typing.Literal[entity_t.EntityType.SPECS], typing.Literal[entity_t.EntityType.GOAL], typing.Literal[entity_t.EntityType.INGREDIENT_TAG_MAP], typing.Literal[entity_t.EntityType.INGREDIENT_TAG], typing.Literal[entity_t.EntityType.OUTPUT]]
+    entity_type: typing.Union[typing.Literal[entity_t.EntityType.LAB_REQUEST], typing.Literal[entity_t.EntityType.APPROVAL], typing.Literal[entity_t.EntityType.CUSTOM_ENTITY], typing.Literal[entity_t.EntityType.INVENTORY_AMOUNT], typing.Literal[entity_t.EntityType.TASK], typing.Literal[entity_t.EntityType.PROJECT], typing.Literal[entity_t.EntityType.EQUIPMENT], typing.Literal[entity_t.EntityType.INV_LOCAL_LOCATIONS], typing.Literal[entity_t.EntityType.FIELD_OPTION_SET], typing.Literal[entity_t.EntityType.WEBHOOK], typing.Literal[entity_t.EntityType.SPECS], typing.Literal[entity_t.EntityType.GOAL], typing.Literal[entity_t.EntityType.INGREDIENT_TAG_MAP], typing.Literal[entity_t.EntityType.INGREDIENT_TAG], typing.Literal[entity_t.EntityType.CONDITION_PARAMETER], typing.Literal[entity_t.EntityType.OUTPUT]]
     entities_to_create: list[EntityToCreate]
 
 

uncountable/types/api/entity/create_entity.py

@@ -44,7 +44,7 @@ class EntityFieldInitialValue:
 @dataclasses.dataclass(kw_only=True)
 class Arguments:
     definition_id: base_t.ObjectId
-    entity_type: typing.Union[typing.Literal[entity_t.EntityType.LAB_REQUEST], typing.Literal[entity_t.EntityType.APPROVAL], typing.Literal[entity_t.EntityType.CUSTOM_ENTITY], typing.Literal[entity_t.EntityType.INVENTORY_AMOUNT], typing.Literal[entity_t.EntityType.TASK], typing.Literal[entity_t.EntityType.PROJECT], typing.Literal[entity_t.EntityType.EQUIPMENT], typing.Literal[entity_t.EntityType.INV_LOCAL_LOCATIONS], typing.Literal[entity_t.EntityType.FIELD_OPTION_SET], typing.Literal[entity_t.EntityType.WEBHOOK], typing.Literal[entity_t.EntityType.SPECS], typing.Literal[entity_t.EntityType.GOAL], typing.Literal[entity_t.EntityType.INGREDIENT_TAG_MAP], typing.Literal[entity_t.EntityType.INGREDIENT_TAG], typing.Literal[entity_t.EntityType.OUTPUT]]
+    entity_type: typing.Union[typing.Literal[entity_t.EntityType.LAB_REQUEST], typing.Literal[entity_t.EntityType.APPROVAL], typing.Literal[entity_t.EntityType.CUSTOM_ENTITY], typing.Literal[entity_t.EntityType.INVENTORY_AMOUNT], typing.Literal[entity_t.EntityType.TASK], typing.Literal[entity_t.EntityType.PROJECT], typing.Literal[entity_t.EntityType.EQUIPMENT], typing.Literal[entity_t.EntityType.INV_LOCAL_LOCATIONS], typing.Literal[entity_t.EntityType.FIELD_OPTION_SET], typing.Literal[entity_t.EntityType.WEBHOOK], typing.Literal[entity_t.EntityType.SPECS], typing.Literal[entity_t.EntityType.GOAL], typing.Literal[entity_t.EntityType.INGREDIENT_TAG_MAP], typing.Literal[entity_t.EntityType.INGREDIENT_TAG], typing.Literal[entity_t.EntityType.CONDITION_PARAMETER], typing.Literal[entity_t.EntityType.OUTPUT]]
     field_values: typing.Optional[typing.Optional[list[field_values_t.FieldRefNameValue]]] = None
 
 

uncountable/types/api/uploader/invoke_uploader.py

@@ -31,9 +31,10 @@ ENDPOINT_PATH = "api/external/uploader/invoke_uploader"
 )
 @dataclasses.dataclass(kw_only=True)
 class Arguments:
-    file_id: base_t.ObjectId
     uploader_key: identifier_t.IdentifierKey
     destination: generic_upload_t.UploadDestination
+    file_id: typing.Optional[base_t.ObjectId] = None
+    file_ids: typing.Optional[list[base_t.ObjectId]] = None
 
 
 # DO NOT MODIFY -- This file is generated by type_spec

uncountable/types/async_batch_processor.py

@@ -233,17 +233,20 @@ class AsyncBatchProcessorBase(ABC):
     def invoke_uploader(
         self,
         *,
-        file_id: base_t.ObjectId,
         uploader_key: identifier_t.IdentifierKey,
         destination: generic_upload_t.UploadDestination,
+        file_id: typing.Optional[base_t.ObjectId] = None,
+        file_ids: typing.Optional[list[base_t.ObjectId]] = None,
         depends_on: typing.Optional[list[str]] = None,
     ) -> async_batch_t.QueuedAsyncBatchRequest:
         """Runs a file through an uploader.
 
+        :param file_id: DEPRECATED: use file_ids
         :param depends_on: A list of batch reference keys to process before processing this request
         """
         args = invoke_uploader_t.Arguments(
             file_id=file_id,
+            file_ids=file_ids,
             uploader_key=uploader_key,
             destination=destination,
         )

uncountable/types/client_base.py

@@ -257,7 +257,7 @@ class ClientMethods(ABC):
         self,
         *,
         definition_id: base_t.ObjectId,
-        entity_type: typing.Union[typing.Literal[entity_t.EntityType.LAB_REQUEST], typing.Literal[entity_t.EntityType.APPROVAL], typing.Literal[entity_t.EntityType.CUSTOM_ENTITY], typing.Literal[entity_t.EntityType.INVENTORY_AMOUNT], typing.Literal[entity_t.EntityType.TASK], typing.Literal[entity_t.EntityType.PROJECT], typing.Literal[entity_t.EntityType.EQUIPMENT], typing.Literal[entity_t.EntityType.INV_LOCAL_LOCATIONS], typing.Literal[entity_t.EntityType.FIELD_OPTION_SET], typing.Literal[entity_t.EntityType.WEBHOOK], typing.Literal[entity_t.EntityType.SPECS], typing.Literal[entity_t.EntityType.GOAL], typing.Literal[entity_t.EntityType.INGREDIENT_TAG_MAP], typing.Literal[entity_t.EntityType.INGREDIENT_TAG], typing.Literal[entity_t.EntityType.OUTPUT]],
+        entity_type: typing.Union[typing.Literal[entity_t.EntityType.LAB_REQUEST], typing.Literal[entity_t.EntityType.APPROVAL], typing.Literal[entity_t.EntityType.CUSTOM_ENTITY], typing.Literal[entity_t.EntityType.INVENTORY_AMOUNT], typing.Literal[entity_t.EntityType.TASK], typing.Literal[entity_t.EntityType.PROJECT], typing.Literal[entity_t.EntityType.EQUIPMENT], typing.Literal[entity_t.EntityType.INV_LOCAL_LOCATIONS], typing.Literal[entity_t.EntityType.FIELD_OPTION_SET], typing.Literal[entity_t.EntityType.WEBHOOK], typing.Literal[entity_t.EntityType.SPECS], typing.Literal[entity_t.EntityType.GOAL], typing.Literal[entity_t.EntityType.INGREDIENT_TAG_MAP], typing.Literal[entity_t.EntityType.INGREDIENT_TAG], typing.Literal[entity_t.EntityType.CONDITION_PARAMETER], typing.Literal[entity_t.EntityType.OUTPUT]],
         entities_to_create: list[create_entities_t.EntityToCreate],
     ) -> create_entities_t.Data:
         """Creates new Uncountable entities
@@ -282,7 +282,7 @@ class ClientMethods(ABC):
         self,
         *,
         definition_id: base_t.ObjectId,
-        entity_type: typing.Union[typing.Literal[entity_t.EntityType.LAB_REQUEST], typing.Literal[entity_t.EntityType.APPROVAL], typing.Literal[entity_t.EntityType.CUSTOM_ENTITY], typing.Literal[entity_t.EntityType.INVENTORY_AMOUNT], typing.Literal[entity_t.EntityType.TASK], typing.Literal[entity_t.EntityType.PROJECT], typing.Literal[entity_t.EntityType.EQUIPMENT], typing.Literal[entity_t.EntityType.INV_LOCAL_LOCATIONS], typing.Literal[entity_t.EntityType.FIELD_OPTION_SET], typing.Literal[entity_t.EntityType.WEBHOOK], typing.Literal[entity_t.EntityType.SPECS], typing.Literal[entity_t.EntityType.GOAL], typing.Literal[entity_t.EntityType.INGREDIENT_TAG_MAP], typing.Literal[entity_t.EntityType.INGREDIENT_TAG], typing.Literal[entity_t.EntityType.OUTPUT]],
+        entity_type: typing.Union[typing.Literal[entity_t.EntityType.LAB_REQUEST], typing.Literal[entity_t.EntityType.APPROVAL], typing.Literal[entity_t.EntityType.CUSTOM_ENTITY], typing.Literal[entity_t.EntityType.INVENTORY_AMOUNT], typing.Literal[entity_t.EntityType.TASK], typing.Literal[entity_t.EntityType.PROJECT], typing.Literal[entity_t.EntityType.EQUIPMENT], typing.Literal[entity_t.EntityType.INV_LOCAL_LOCATIONS], typing.Literal[entity_t.EntityType.FIELD_OPTION_SET], typing.Literal[entity_t.EntityType.WEBHOOK], typing.Literal[entity_t.EntityType.SPECS], typing.Literal[entity_t.EntityType.GOAL], typing.Literal[entity_t.EntityType.INGREDIENT_TAG_MAP], typing.Literal[entity_t.EntityType.INGREDIENT_TAG], typing.Literal[entity_t.EntityType.CONDITION_PARAMETER], typing.Literal[entity_t.EntityType.OUTPUT]],
         field_values: typing.Optional[typing.Optional[list[field_values_t.FieldRefNameValue]]] = None,
     ) -> create_entity_t.Data:
         """Creates a new Uncountable entity
@@ -876,15 +876,18 @@ class ClientMethods(ABC):
     def invoke_uploader(
         self,
         *,
-        file_id: base_t.ObjectId,
         uploader_key: identifier_t.IdentifierKey,
         destination: generic_upload_t.UploadDestination,
+        file_id: typing.Optional[base_t.ObjectId] = None,
+        file_ids: typing.Optional[list[base_t.ObjectId]] = None,
     ) -> invoke_uploader_t.Data:
         """Runs a file through an uploader.
 
+        :param file_id: DEPRECATED: use file_ids
         """
         args = invoke_uploader_t.Arguments(
             file_id=file_id,
+            file_ids=file_ids,
             uploader_key=uploader_key,
             destination=destination,
         )

uncountable/types/entity_t.py

@@ -111,6 +111,7 @@ __all__: list[str] = [
         "recipe_calculation": "Recipe Calculation",
         "recipe_check": "Experiment Check",
         "recipe_export": "Recipe Export",
+        "recipe_goal": "Experiment Goal",
         "recipe_ingredient": "Recipe Ingredient",
         "recipe_ingredient_actual": "Recipe Ingredient Actual",
         "recipe_ingredients_compounded": "Recipe Ingredients Compounded",
@@ -265,6 +266,7 @@ class EntityType(StrEnum):
     RECIPE_CALCULATION = "recipe_calculation"
     RECIPE_CHECK = "recipe_check"
     RECIPE_EXPORT = "recipe_export"
+    RECIPE_GOAL = "recipe_goal"
     RECIPE_INGREDIENT = "recipe_ingredient"
     RECIPE_INGREDIENT_ACTUAL = "recipe_ingredient_actual"
     RECIPE_INGREDIENTS_COMPOUNDED = "recipe_ingredients_compounded"