UncountablePythonSDK 0.0.89__py3-none-any.whl → 0.0.91__py3-none-any.whl

pkgs/serialization/serial_class.py

@@ -5,20 +5,18 @@ from collections.abc import Callable
 from enum import StrEnum
 from typing import Any, Optional, TypeVar, cast
 
+from .annotation import SerialBase, SerialInspector
+
 _ClassT = TypeVar("_ClassT")
 
 
-@dataclasses.dataclass
-class _SerialClassData:
+@dataclasses.dataclass(kw_only=True, frozen=True, eq=True)
+class _SerialClassData(SerialBase):
     unconverted_keys: set[str] = dataclasses.field(default_factory=set)
     unconverted_values: set[str] = dataclasses.field(default_factory=set)
     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()
@@ -31,6 +29,7 @@ def serial_class(
     to_string_values: Optional[set[str]] = None,
     parse_require: Optional[set[str]] = None,
     named_type_path: Optional[str] = None,
+    is_dynamic_allowed: bool = False,
 ) -> Callable[[_ClassT], _ClassT]:
     """
     An additional decorator to a dataclass that specifies serialization options.
@@ -63,17 +62,20 @@ def serial_class(
             parse_require=parse_require or set(),
             named_type_path=named_type_path,
             from_decorator=True,
+            is_dynamic_allowed=is_dynamic_allowed,
         )
         return orig_class
 
     return decorate
 
 
-class SerialClassDataInspector:
+class SerialClassDataInspector(SerialInspector[_ClassT]):
     def __init__(
         self,
+        parsed_type: type[_ClassT],
         current: _SerialClassData,
     ) -> None:
+        super().__init__(parsed_type, current)
         self.current = current
 
     def has_unconverted_key(self, key: str) -> bool:
@@ -88,20 +90,8 @@ 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
-
-    @property
-    def is_field_proper(self) -> bool:
-        return self.current.from_decorator and self.current.named_type_path is not None
 
-
-def _get_merged_serial_class_data(type_class: type[Any]) -> _SerialClassData | None:
+def get_merged_serial_class_data(type_class: type[Any]) -> _SerialClassData | None:
     base_class_data = (
         cast(_SerialClassData, type_class.__unc_serial_data)
         if hasattr(type_class, "__unc_serial_data")
@@ -110,26 +100,30 @@ def _get_merged_serial_class_data(type_class: type[Any]) -> _SerialClassData | N
     if base_class_data is None:
         return None
 
+    # IMPROVE: We should cache this result on the type
     if type_class.__bases__ is not None:
         for base in type_class.__bases__:
-            curr_base_class_data = _get_merged_serial_class_data(base)
+            curr_base_class_data = get_merged_serial_class_data(base)
             if curr_base_class_data is not None:
-                base_class_data.unconverted_keys |= (
-                    curr_base_class_data.unconverted_keys
-                )
-                base_class_data.unconverted_values |= (
-                    curr_base_class_data.unconverted_values
-                )
-                base_class_data.to_string_values |= (
-                    curr_base_class_data.to_string_values
+                base_class_data = dataclasses.replace(
+                    base_class_data,
+                    unconverted_keys=base_class_data.unconverted_keys
+                    | curr_base_class_data.unconverted_keys,
+                    unconverted_values=base_class_data.unconverted_values
+                    | curr_base_class_data.unconverted_values,
+                    to_string_values=base_class_data.to_string_values
+                    | curr_base_class_data.to_string_values,
+                    parse_require=base_class_data.parse_require
+                    | curr_base_class_data.parse_require,
                 )
-                base_class_data.parse_require |= curr_base_class_data.parse_require
     return base_class_data
 
 
-def get_serial_class_data(type_class: type[Any]) -> SerialClassDataInspector:
+def get_serial_class_data(
+    type_class: type[_ClassT],
+) -> SerialClassDataInspector[_ClassT]:
     return SerialClassDataInspector(
-        _get_merged_serial_class_data(type_class) or EMPTY_SERIAL_CLASS_DATA
+        type_class, get_merged_serial_class_data(type_class) or EMPTY_SERIAL_CLASS_DATA
     )
 
 

pkgs/serialization/serial_generic.py

@@ -0,0 +1,16 @@
+import typing
+
+from .annotation import SerialInspector, get_serial_annotation
+from .serial_class import get_merged_serial_class_data
+
+T = typing.TypeVar("T")
+
+
+def get_serial_data(parsed_type: type[T]) -> SerialInspector[T] | None:
+    serial = get_serial_annotation(parsed_type)
+    if serial is None:
+        serial = get_merged_serial_class_data(parsed_type)
+
+    if serial is not None:
+        return SerialInspector(parsed_type, serial)
+    return None

pkgs/serialization/serial_union.py

@@ -1,6 +1,8 @@
 import dataclasses
 import typing
 
+from .annotation import SerialBase, SerialInspector, get_serial_annotation
+
 T = typing.TypeVar("T")
 
 
@@ -17,7 +19,7 @@ class IdentityHashWrapper(typing.Generic[T]):
 
 
 @dataclasses.dataclass(kw_only=True, frozen=True, eq=True)
-class _SerialUnion:
+class _SerialUnion(SerialBase):
     """
     This class is to be kept private, to provide flexibility in registration/lookup.
     Places that need the data should access it via help classes/methods.
@@ -27,7 +29,6 @@ class _SerialUnion:
     # determine which type to parse.
     discriminator: typing.Optional[str] = None
     discriminator_map: typing.Optional[IdentityHashWrapper[dict[str, type]]] = None
-    named_type_path: typing.Optional[str] = None
 
 
 def serial_union_annotation(
@@ -35,6 +36,7 @@ def serial_union_annotation(
     discriminator: typing.Optional[str] = None,
     discriminator_map: typing.Optional[dict[str, type]] = None,
     named_type_path: typing.Optional[str] = None,
+    is_dynamic_allowed: bool = False,
 ) -> _SerialUnion:
     return _SerialUnion(
         discriminator=discriminator,
@@ -42,23 +44,21 @@ def serial_union_annotation(
         if discriminator_map is not None
         else None,
         named_type_path=named_type_path,
+        from_decorator=True,
+        is_dynamic_allowed=is_dynamic_allowed,
     )
 
 
 def _get_serial_union(parsed_type: type[T]) -> _SerialUnion | None:
-    if not hasattr(parsed_type, "__metadata__"):
-        return None
-    metadata = parsed_type.__metadata__  # type:ignore[attr-defined]
-    if not isinstance(metadata, tuple) or len(metadata) != 1:
-        return None
-    serial = metadata[0]
+    serial = get_serial_annotation(parsed_type)
     if not isinstance(serial, _SerialUnion):
         return None
     return serial
 
 
-class SerialClassInspector(typing.Generic[T]):
+class SerialClassInspector(SerialInspector[T]):
     def __init__(self, parsed_type: type[T], serial_union: _SerialUnion) -> None:
+        super().__init__(parsed_type, serial_union)
         self._parsed_type = parsed_type
         self._serial_union = serial_union
 

pkgs/serialization_util/__init__.py

@@ -1,4 +1,6 @@
 from .convert_to_snakecase import convert_dict_to_snake_case
+from .dataclasses import dict_fields as dict_fields
+from .dataclasses import iterate_fields as iterate_fields
 from .serialization_helpers import (
     serialize_for_api,
     serialize_for_storage,
@@ -10,4 +12,6 @@ __all__: list[str] = [
     "serialize_for_api",
     "serialize_for_storage",
     "serialize_for_storage_dict",
+    "iterate_fields",
+    "dict_fields",
 ]

pkgs/serialization_util/dataclasses.py

@@ -0,0 +1,14 @@
+from dataclasses import fields
+from typing import TYPE_CHECKING, Any, Iterator
+
+if TYPE_CHECKING:
+    from _typeshed import DataclassInstance
+
+
+def iterate_fields(d: "DataclassInstance") -> Iterator[tuple[str, Any]]:
+    for field in fields(d):
+        yield field.name, getattr(d, field.name)
+
+
+def dict_fields(d: "DataclassInstance") -> dict[str, Any]:
+    return dict(iterate_fields(d))

pkgs/serialization_util/serialization_helpers.py

@@ -25,6 +25,7 @@ from pkgs.serialization import (
 )
 
 from ._get_type_for_serialization import SerializationType, get_serialization_type
+from .dataclasses import iterate_fields
 
 # Inlined types which otherwise would import from types/base.py
 JsonScalar = Union[str, float, bool, Decimal, None, datetime.datetime, datetime.date]
@@ -77,6 +78,12 @@ def _serialize_dict(d: dict[str, Any]) -> dict[str, JsonValue]:
     return {k: serialize_for_storage(v) for k, v in d.items() if v != MISSING_SENTRY}
 
 
+def _serialize_dataclass(d: Any) -> dict[str, JsonValue]:
+    return {
+        k: serialize_for_storage(v) for k, v in iterate_fields(d) if v != MISSING_SENTRY
+    }
+
+
 def _to_string_value(value: Any) -> str:
     assert isinstance(value, (Decimal, int))
     return str(value)
@@ -121,7 +128,7 @@ def _convert_dataclass(d: Any) -> dict[str, JsonValue]:
         conversions.key_conversions[k]: (
             conversions.value_conversion_functions[k](v) if v is not None else None
         )
-        for k, v in d.__dict__.items()
+        for k, v in iterate_fields(d)
         if v != MISSING_SENTRY
     }
 
@@ -169,14 +176,15 @@ def serialize_for_api(obj: Any) -> JsonValue:
         serialization_type == SerializationType.UNKNOWN
     ):  # performance optimization to not do function lookup
         return obj  # type: ignore
-    return _CONVERSION_SERIALIZATION_FUNCS[serialization_type](obj)
+    r = _CONVERSION_SERIALIZATION_FUNCS[serialization_type](obj)
+    return r
 
 
 _SERIALIZATION_FUNCS_DICT: dict[
     SerializationType, Callable[[Any], dict[str, JsonValue]]
 ] = {
     SerializationType.DICT: _serialize_dict,
-    SerializationType.DATACLASS: lambda x: _serialize_dict(x.__dict__),
+    SerializationType.DATACLASS: _serialize_dataclass,
 }
 
 

pkgs/type_spec/builder.py

@@ -293,6 +293,7 @@ class SpecTypeDefn(SpecType):
         self._is_value_converted = _is_value_converted
         self._is_value_to_string = False
         self._is_valid_parameter = True
+        self._is_dynamic_allowed = False
         self.ext_info: Any = None
 
     def is_value_converted(self) -> bool:
@@ -304,6 +305,9 @@ class SpecTypeDefn(SpecType):
     def is_valid_parameter(self) -> bool:
         return self._is_valid_parameter
 
+    def is_dynamic_allowed(self) -> bool:
+        return self._is_dynamic_allowed
+
     def is_base_type(self, type_: BaseTypeName) -> bool:
         return self.is_base and self.name == type_
 
@@ -316,11 +320,23 @@ class SpecTypeDefn(SpecType):
     def base_process(
         self, builder: SpecBuilder, data: RawDict, extra_names: list[str]
     ) -> None:
-        util.check_fields(data, ["ext_info", "label"] + extra_names)
+        util.check_fields(
+            data,
+            [
+                "ext_info",
+                "label",
+                "is_dynamic_allowed",
+            ]
+            + extra_names,
+        )
 
         self.ext_info = data.get("ext_info")
         self.label = data.get("label")
 
+        is_dynamic_allowed = data.get("is_dynamic_allowed", False)
+        assert isinstance(is_dynamic_allowed, bool)
+        self._is_dynamic_allowed = is_dynamic_allowed
+
     def _process_property(
         self, builder: SpecBuilder, spec_name: str, data: RawDict
     ) -> SpecProperty:
@@ -818,6 +834,12 @@ def _resolve_endpoint_path(
     )
 
 
+class EndpointEmitType(StrEnum):
+    EMIT_ENDPOINT = "emit_endpoint"
+    EMIT_TYPES = "emit_types"
+    EMIT_NOTHING = "emit_nothing"
+
+
 class SpecEndpoint:
     method: RouteMethod
     root: str
@@ -825,7 +847,7 @@ class SpecEndpoint:
     path_dirname: str
     path_basename: str
     data_loader: bool
-    is_sdk: bool
+    is_sdk: EndpointEmitType
     is_beta: bool
     stability_level: StabilityLevel | None
     # Don't emit TypeScript endpoint code
@@ -879,8 +901,22 @@ class SpecEndpoint:
         assert isinstance(data_loader, bool)
         self.data_loader = data_loader
 
-        is_sdk = data.get("is_sdk", False)
-        assert isinstance(is_sdk, bool)
+        is_sdk = data.get("is_sdk", EndpointEmitType.EMIT_NOTHING)
+
+        # backwards compatibility
+        if isinstance(is_sdk, bool):
+            if is_sdk is True:
+                is_sdk = EndpointEmitType.EMIT_ENDPOINT
+            else:
+                is_sdk = EndpointEmitType.EMIT_NOTHING
+        elif isinstance(is_sdk, str):
+            try:
+                is_sdk = EndpointEmitType(is_sdk)
+            except ValueError:
+                raise ValueError(f"Invalid value for is_sdk: {is_sdk}")
+
+        assert isinstance(is_sdk, EndpointEmitType)
+
         self.is_sdk = is_sdk
 
         route_group = data.get("route_group")
@@ -924,7 +960,7 @@ class SpecEndpoint:
         self.is_external = self.path_root == "api/external"
         self.has_attachment = data.get("has_attachment", False)
 
-        assert not is_sdk or self.desc is not None, (
+        assert self.is_sdk != EndpointEmitType.EMIT_ENDPOINT or self.desc is not None, (
             f"Endpoint description required for SDK endpoints, missing: {path}"
         )
 

pkgs/type_spec/emit_python.py

@@ -5,6 +5,7 @@ from decimal import Decimal
 from typing import Any, Optional
 
 from . import builder, util
+from .builder import EndpointEmitType
 from .config import PythonConfig
 
 INDENT = "    "
@@ -45,6 +46,7 @@ class TrackingContext:
     use_serial_string_enum: bool = False
     use_dataclass: bool = False
     use_serial_union: bool = False
+    use_serial_alias: bool = False
     use_missing: bool = False
     use_opaque_key: bool = False
 
@@ -225,6 +227,8 @@ def _emit_types_imports(*, out: io.StringIO, ctx: Context) -> None:
         out.write("from pkgs.serialization import serial_class\n")
     if ctx.use_serial_union:
         out.write("from pkgs.serialization import serial_union_annotation\n")
+    if ctx.use_serial_alias:
+        out.write("from pkgs.serialization import serial_alias_annotation\n")
     if ctx.use_serial_string_enum:
         out.write("from pkgs.serialization import serial_string_enum\n")
     if ctx.use_missing:
@@ -249,7 +253,7 @@ def _emit_types(*, builder: builder.SpecBuilder, config: PythonConfig) -> None:
     ):
         if (
             namespace.endpoint is not None
-            and not namespace.endpoint.is_sdk
+            and namespace.endpoint.is_sdk == EndpointEmitType.EMIT_NOTHING
             and config.sdk_endpoints_only is True
         ):
             continue
@@ -486,7 +490,10 @@ def _emit_async_batch_invocation_function(
     endpoint = namespace.endpoint
     if endpoint is None:
         return
-    if endpoint.async_batch_path is None or not endpoint.is_sdk:
+    if (
+        endpoint.async_batch_path is None
+        or endpoint.is_sdk != EndpointEmitType.EMIT_ENDPOINT
+    ):
         return
 
     ctx.out.write("\n")
@@ -568,7 +575,7 @@ def _emit_endpoint_invocation_function(
     endpoint = namespace.endpoint
     if endpoint is None:
         return
-    if not endpoint.is_sdk or endpoint.is_beta:
+    if endpoint.is_sdk != EndpointEmitType.EMIT_ENDPOINT or endpoint.is_beta:
         return
 
     ctx.out.write("\n")
@@ -779,7 +786,17 @@ def _emit_type(ctx: Context, stype: builder.SpecType) -> None:
         return
 
     if isinstance(stype, builder.SpecTypeDefnAlias):
-        ctx.out.write(f"{stype.name} = {refer_to(ctx, stype.alias)}\n")
+        ctx.use_serial_alias = True
+        ctx.out.write(f"{stype.name} = typing.Annotated[\n")
+        ctx.out.write(f"{INDENT}{refer_to(ctx, stype.alias)},\n")
+        ctx.out.write(f"{INDENT}serial_alias_annotation(\n")
+        ctx.out.write(
+            f"{INDENT}named_type_path={util.encode_common_string(_named_type_path(ctx, stype))},\n"
+        )
+        if stype.is_dynamic_allowed():
+            ctx.out.write(f"{INDENT}is_dynamic_allowed=True,\n")
+        ctx.out.write(f"{INDENT}),\n")
+        ctx.out.write("]\n")
         return
 
     if isinstance(stype, builder.SpecTypeDefnUnion):
@@ -790,6 +807,8 @@ def _emit_type(ctx: Context, stype: builder.SpecType) -> None:
         ctx.out.write(
             f"{INDENT}named_type_path={util.encode_common_string(_named_type_path(ctx, stype))},\n"
         )
+        if stype.is_dynamic_allowed():
+            ctx.out.write(f"{INDENT}is_dynamic_allowed=True,\n")
         if stype.discriminator is not None:
             ctx.out.write(
                 f"{INDENT * 2}discriminator={util.encode_common_string(stype.discriminator)},\n"
@@ -836,6 +855,8 @@ def _emit_type(ctx: Context, stype: builder.SpecType) -> None:
     ctx.out.write(
         f"{INDENT}named_type_path={util.encode_common_string(_named_type_path(ctx, stype))},\n"
     )
+    if stype.is_dynamic_allowed():
+        ctx.out.write(f"{INDENT}is_dynamic_allowed=True,\n")
 
     def write_values(key: str, values: set[str]) -> None:
         if len(values) == 0:
@@ -1027,13 +1048,19 @@ def _emit_namespace_imports(
     namespaces: set[builder.SpecNamespace],
     from_namespace: Optional[builder.SpecNamespace],
     config: PythonConfig,
+    skip_non_sdk: bool = False,
 ) -> None:
     for ns in sorted(
         namespaces,
         key=lambda name: _resolve_namespace_name(name),
     ):
+        if (
+            skip_non_sdk
+            and ns.endpoint is not None
+            and ns.endpoint.is_sdk != EndpointEmitType.EMIT_ENDPOINT
+        ):
+            continue
         resolved = _resolve_namespace_name(ns)
-        ref = _resolve_namespace_ref(ns)
         if ns.endpoint is not None:
             import_alias = "_".join(ns.path[2:]) + "_t"
             out.write(
@@ -1193,7 +1220,7 @@ def _emit_api_argument_lookup(
                 continue
             if endpoint.function is None:
                 continue
-            if "Arguments" not in namespace.types:
+            if "Arguments" not in namespace.types or "Data" not in namespace.types:
                 continue
 
             import_alias = "_".join(namespace.path[1:])
@@ -1357,6 +1384,7 @@ def _emit_client_class(
         namespaces=ctx.namespaces,
         from_namespace=None,
         config=config,
+        skip_non_sdk=True,
     )
 
     client_base_out.write(

pkgs/type_spec/type_info/emit_type_info.py

@@ -201,8 +201,13 @@ def _extract_inheritable_property_parts(
     elif base_parts.ext_info is None:
         ext_info = local_ext_info
     else:
-        ext_info = type_info_t.ExtInfo(
-            **(local_ext_info.__dict__ | base_parts.ext_info.__dict__)
+        ext_info = dataclasses.replace(
+            local_ext_info,
+            **{
+                field.name: getattr(base_parts.ext_info, field.name)
+                for field in dataclasses.fields(type_info_t.ExtInfo)
+                if getattr(base_parts.ext_info, field.name) is not None
+            },
         )
 
     return InheritablePropertyParts(label=label, desc=desc, ext_info=ext_info)

pkgs/type_spec/value_spec/convert_type.py

@@ -31,6 +31,11 @@ TYPE_MAP = {
     # not part of type_spec's types now
     "Symbol": MappedType(base_type=value_spec_t.BaseType.SYMBOL),
     "Any": MappedType(base_type=value_spec_t.BaseType.ANY),
+    "None": MappedType(base_type=value_spec_t.BaseType.NONE),
+    "Tuple": MappedType(
+        base_type=value_spec_t.BaseType.TUPLE, variable_param_count=True
+    ),
+    "Never": MappedType(base_type=value_spec_t.BaseType.NEVER),
 }
 
 

uncountable/core/client.py

@@ -1,9 +1,11 @@
 import base64
+import re
 import typing
 from dataclasses import dataclass
 from datetime import datetime, timedelta
 from enum import StrEnum
-from urllib.parse import urljoin
+from io import BytesIO
+from urllib.parse import unquote, urljoin
 from uuid import uuid4
 
 import requests
@@ -16,6 +18,7 @@ from pkgs.serialization_util import serialize_for_api
 from pkgs.serialization_util.serialization_helpers import JsonValue
 from uncountable.core.environment import get_version
 from uncountable.integration.telemetry import JobLogger
+from uncountable.types import download_file_t
 from uncountable.types.client_base import APIRequest, ClientMethods
 from uncountable.types.client_config import ClientConfigOptions
 
@@ -157,6 +160,16 @@ class GetOauthBearerTokenData:
 oauth_bearer_token_data_parser = CachedParser(GetOauthBearerTokenData)
 
 
+@dataclass
+class DownloadedFile:
+    name: str
+    size: int
+    data: BytesIO
+
+
+DownloadedFiles = list[DownloadedFile]
+
+
 class Client(ClientMethods):
     _parser_map: dict[type, CachedParser] = {}
     _auth_details: AuthDetailsAll
@@ -313,6 +326,50 @@ class Client(ClientMethods):
             case _:
                 raise ValueError(f"unsupported request method: {method}")
 
+    def _get_downloaded_filename(self, *, cd: typing.Optional[str]) -> str:
+        if not cd:
+            return "Unknown"
+
+        fname = re.findall(r"filename\*=UTF-8''(.+)", cd)
+        if fname:
+            return unquote(fname[0])
+
+        fname = re.findall(r'filename="?(.+)"?', cd)
+        if fname:
+            return str(fname[0].strip('"'))
+
+        return "Unknown"
+
+    def download_files(
+        self, *, file_query: download_file_t.FileDownloadQuery
+    ) -> DownloadedFiles:
+        """Download a file from uncountable."""
+        request_id = str(uuid4())
+        api_request = APIRequest(
+            method=download_file_t.ENDPOINT_METHOD,
+            endpoint=download_file_t.ENDPOINT_PATH,
+            args=download_file_t.Arguments(
+                file_query=file_query,
+            ),
+        )
+        http_request = self._build_http_request(
+            api_request=api_request, request_id=request_id
+        )
+        request = requests.Request(http_request.method.value, http_request.url)
+        request.headers = http_request.headers
+        assert isinstance(http_request, HTTPGetRequest)
+        request.params = http_request.query_params
+        response = self._send_request(request)
+        content = response.content
+        content_disposition = response.headers.get("Content-Disposition", None)
+        return [
+            DownloadedFile(
+                name=self._get_downloaded_filename(cd=content_disposition),
+                size=len(content),
+                data=BytesIO(content),
+            )
+        ]
+
     def upload_files(
         self: typing.Self, *, file_uploads: list[FileUpload]
     ) -> list[UploadedFile]:

uncountable/core/environment.py

@@ -19,11 +19,11 @@ def get_server_env() -> str | None:
 
 
 def get_webhook_server_port() -> int:
-    return int(os.environ.get("UNC_WEBHOOK_SERVER_PORT", 5001))
+    return int(os.environ.get("UNC_WEBHOOK_SERVER_PORT", "5001"))
 
 
 def get_local_admin_server_port() -> int:
-    return int(os.environ.get("UNC_ADMIN_SERVER_PORT", 50051))
+    return int(os.environ.get("UNC_ADMIN_SERVER_PORT", "50051"))
 
 
 def get_otel_enabled() -> bool:

uncountable/integration/scheduler.py

@@ -92,19 +92,19 @@ def check_process_alive(logger: Logger, processes: list[ProcessInfo]) -> None:
 
 
 def _wait_queue_runner_online() -> None:
-    _MAX_QUEUE_RUNNER_HEALTH_CHECKS = 10
-    _QUEUE_RUNNER_HEALTH_CHECK_DELAY_SECS = 1
+    MAX_QUEUE_RUNNER_HEALTH_CHECKS = 10
+    QUEUE_RUNNER_HEALTH_CHECK_DELAY_SECS = 1
 
     num_attempts = 0
     before = datetime.now(timezone.utc)
-    while num_attempts < _MAX_QUEUE_RUNNER_HEALTH_CHECKS:
+    while num_attempts < MAX_QUEUE_RUNNER_HEALTH_CHECKS:
         try:
             if check_health(port=get_local_admin_server_port()):
                 return
         except CommandServerTimeout:
             pass
         num_attempts += 1
-        time.sleep(_QUEUE_RUNNER_HEALTH_CHECK_DELAY_SECS)
+        time.sleep(QUEUE_RUNNER_HEALTH_CHECK_DELAY_SECS)
     after = datetime.now(timezone.utc)
     duration_secs = (after - before).seconds
     raise Exception(f"queue runner failed to come online after {duration_secs} seconds")

uncountable/types/__init__.py

@@ -25,6 +25,7 @@ from .api.recipe_links import create_recipe_link as create_recipe_link_t
 from .api.recipes import create_recipes as create_recipes_t
 from . import curves_t as curves_t
 from .api.recipes import disassociate_recipe_as_input as disassociate_recipe_as_input_t
+from .api.files import download_file as download_file_t
 from .api.recipes import edit_recipe_inputs as edit_recipe_inputs_t
 from . import entity_t as entity_t
 from .api.batch import execute_batch as execute_batch_t
@@ -132,6 +133,7 @@ __all__: list[str] = [
     "create_recipes_t",
     "curves_t",
     "disassociate_recipe_as_input_t",
+    "download_file_t",
     "edit_recipe_inputs_t",
     "entity_t",
     "execute_batch_t",