UncountablePythonSDK 0.0.92__py3-none-any.whl → 0.0.95__py3-none-any.whl

pkgs/type_spec/builder.py

@@ -901,16 +901,9 @@ class SpecEndpoint:
     account_type: str | None
     route_group: str | None
 
-    # to be deprecated in favor of path_per_api_endpoint:
-    # default function, path details
-    function: str | None
-    root: EndpointKey
-    path_root: str
-    path_dirname: str
-    path_basename: str
-
     # function, path details per api endpoint
     path_per_api_endpoint: dict[str, EndpointSpecificPath]
+    default_endpoint_key: EndpointKey
 
     is_external: bool = False
 
@@ -997,14 +990,18 @@ class SpecEndpoint:
         self.has_attachment = data.get("has_attachment", False)
         self.desc = data.get("desc")
 
+        # compatibility with single-endpoint files
         default_endpoint_path = parse_endpoint_specific_path(
             builder,
             {"path": data.get("path"), "function": data.get("function")},
         )
         if default_endpoint_path is not None:
-            self.root = default_endpoint_path.root
+            assert default_endpoint_path.root in builder.api_endpoints, (
+                "Default endpoint is not a valid API endpoint"
+            )
+            self.default_endpoint_key = default_endpoint_path.root
             self.path_per_api_endpoint = {
-                self.root: default_endpoint_path,
+                self.default_endpoint_key: default_endpoint_path,
             }
         else:
             self.path_per_api_endpoint = {}
@@ -1021,27 +1018,34 @@ class SpecEndpoint:
                         if shared_function_name is None:
                             shared_function_name = fn_name
                         assert shared_function_name == fn_name
-            assert self.path_per_api_endpoint != {}
 
-            assert builder.top_namespace in self.path_per_api_endpoint
-            self.root = builder.top_namespace
+            if builder.top_namespace in self.path_per_api_endpoint:
+                self.default_endpoint_key = builder.top_namespace
+            elif len(self.path_per_api_endpoint) == 1:
+                self.default_endpoint_key = next(
+                    iter(self.path_per_api_endpoint.keys())
+                )
+            else:
+                raise RuntimeError("no clear default endpoint")
 
-        default_endpoint_path = self.path_per_api_endpoint[self.root]
-        self.function = default_endpoint_path.function
-        self.path_dirname = default_endpoint_path.path_dirname
-        self.path_basename = default_endpoint_path.path_basename
-        self.path_root = default_endpoint_path.path_root
+        assert len(self.path_per_api_endpoint) > 0, (
+            "Missing API endpoint path and function definitions for API call"
+        )
 
         # IMPROVE: remove need for is_external flag
-        self.is_external = self.path_root == "api/external"
+        self.is_external = (
+            self.path_per_api_endpoint[self.default_endpoint_key].path_root
+            == "api/external"
+        )
 
         assert self.is_sdk != EndpointEmitType.EMIT_ENDPOINT or self.desc is not None, (
-            f"Endpoint description required for SDK endpoints, missing: {self.path_dirname}/{self.path_basename}"
+            f"Endpoint description required for SDK endpoints, missing: {self.resolved_path}"
         )
 
     @property
     def resolved_path(self: Self) -> str:
-        return f"{self.path_root}/{self.path_dirname}/{self.path_basename}"
+        default_endpoint_path = self.path_per_api_endpoint[self.default_endpoint_key]
+        return f"{default_endpoint_path.path_root}/{default_endpoint_path.path_dirname}/{default_endpoint_path.path_basename}"
 
 
 def _parse_const(

pkgs/type_spec/config.py

@@ -1,7 +1,7 @@
 import os
 from collections.abc import Callable, Mapping
 from dataclasses import dataclass
-from typing import Self, TypeVar
+from typing import Self
 
 from pkgs.serialization import yaml
 
@@ -103,10 +103,7 @@ class Config:
     open_api: OpenAPIConfig | None
 
 
-_T = TypeVar("_T")
-
-
-def _parse_language(config_class: type[_T], raw_value: ConfigValueType) -> _T:
+def _parse_language[_T](config_class: type[_T], raw_value: ConfigValueType) -> _T:
     assert isinstance(raw_value, dict), "expecting language config to have key/values."
     return config_class(**raw_value)
 

pkgs/type_spec/emit_open_api.py

@@ -563,7 +563,7 @@ def _emit_endpoint(
     ep = namespace.endpoint
     gctx.paths.append(
         EmitOpenAPIPath(
-            path=f"/{ep.path_root}/{ep.path_dirname}/{ep.path_basename}",
+            path=f"/{ep.resolved_path}",
             ref=ref_path,
         )
     )

pkgs/type_spec/emit_python.py

@@ -5,16 +5,14 @@ from decimal import Decimal
 from typing import Any
 
 from . import builder, util
-from .builder import EndpointEmitType
+from .builder import EndpointEmitType, EndpointSpecificPath
 from .config import PythonConfig
 
 INDENT = "    "
 LINE_BREAK = "\n"
 MODIFY_NOTICE = "# DO NOT MODIFY -- This file is generated by type_spec\n"
 # Turn excess line length warning and turn off ruff formatting
-LINT_HEADER = (
-    "# flake8: noqa: F821\n# ruff: noqa: E402 Q003\n# fmt: off\n# isort: skip_file\n"
-)
+LINT_HEADER = "# ruff: noqa: E402 Q003\n# fmt: off\n# isort: skip_file\n"
 LINT_FOOTER = "# fmt: on\n"
 ROUTE_NOTICE = """# Routes are generated from $endpoint specifications in the
 # type_spec API YAML files. Refer to the section on endpoints in the type_spec/README"""
@@ -221,7 +219,7 @@ def _emit_types_imports(*, out: io.StringIO, ctx: Context) -> None:
     out.write("import datetime  # noqa: F401\n")
     out.write("from decimal import Decimal  # noqa: F401\n")
     if ctx.use_enum:
-        out.write("from pkgs.strenum_compat import StrEnum\n")
+        out.write("from enum import StrEnum\n")
     if ctx.use_dataclass:
         out.write("import dataclasses\n")
         out.write("from pkgs.serialization import serial_class\n")
@@ -349,13 +347,17 @@ ENDPOINT_PATH = "ENDPOINT_PATH"
 ENDPOINT_PATH_ALTERNATE = "ENDPOINT_PATH_ALTERNATE"
 
 
+def _get_epf_root(endpoint_specific_path: EndpointSpecificPath) -> str:
+    return endpoint_specific_path.root
+
+
 def _emit_namespace(ctx: Context, namespace: builder.SpecNamespace) -> None:
     endpoint = namespace.endpoint
     if endpoint is not None:
         ctx.out.write("\n")
         ctx.out.write(f'{ENDPOINT_METHOD} = "{endpoint.method.upper()}"\n')
         for endpoint_specific_path in sorted(
-            endpoint.path_per_api_endpoint.values(), key=lambda epf: epf.root
+            endpoint.path_per_api_endpoint.values(), key=_get_epf_root
         ):
             endpoint_path_name = ENDPOINT_PATH
 
@@ -457,8 +459,10 @@ def _emit_endpoint_invocation_function_signature(
         else []
     ) + (extra_params if extra_params is not None else [])
 
-    assert endpoint.function is not None
-    function_name = endpoint.function.split(".")[-1]
+    # All endpoints share a function name
+    function = endpoint.path_per_api_endpoint[endpoint.default_endpoint_key].function
+    assert function is not None
+    function_name = function.split(".")[-1]
     ctx.out.write(
         f"""
     def {function_name}(
@@ -716,40 +720,43 @@ def _emit_properties(
     if len(properties) > 0:
 
         def write_field(prop: builder.SpecProperty) -> None:
+            stype = prop.spec_type
             if prop.name_case == builder.NameCase.preserve:
                 unconverted_keys.add(prop.name)
             py_name = python_field_name(prop.name, prop.name_case)
 
             if prop.convert_value == builder.PropertyConvertValue.no_convert:
                 unconverted_values.add(py_name)
-            elif not prop.spec_type.is_value_converted():
+            elif not stype.is_value_converted():
                 assert prop.convert_value == builder.PropertyConvertValue.auto
                 unconverted_values.add(py_name)
-            if prop.spec_type.is_value_to_string():
+            if stype.is_value_to_string():
                 to_string_values.add(py_name)
 
             if prop.parse_require:
                 parse_require.add(py_name)
 
-            ref_type = refer_to(ctx, prop.spec_type)
+            ref_type = refer_to(ctx, stype)
             default = None
             if prop.extant == builder.PropertyExtant.missing:
                 ref_type = f"MissingType[{ref_type}]"
                 default = "MISSING_SENTRY"
                 ctx.use_missing = True
             elif prop.extant == builder.PropertyExtant.optional:
-                if ref_type != "None":
+                if isinstance(
+                    stype, builder.SpecTypeInstance
+                ) and stype.defn_type.is_base_type(builder.BaseTypeName.s_optional):
+                    pass  # base type already adds the None union
+                elif ref_type == "None":
+                    pass  # no need to add a None union to a none type
+                else:
                     ref_type = f"{ref_type} | None"
                 default = "None"
             elif prop.has_default:
-                default = _emit_value(ctx, prop.spec_type, prop.default)
+                default = _emit_value(ctx, stype, prop.default)
                 if (
-                    isinstance(prop.spec_type, builder.SpecTypeInstance)
-                    and (
-                        prop.spec_type.defn_type.is_base_type(
-                            builder.BaseTypeName.s_list
-                        )
-                    )
+                    isinstance(stype, builder.SpecTypeInstance)
+                    and (stype.defn_type.is_base_type(builder.BaseTypeName.s_list))
                     and default == "[]"
                 ):
                     default = "dataclasses.field(default_factory=list)"
@@ -939,13 +946,22 @@ base_name_map = {
 
 def refer_to(ctx: TrackingContext, stype: builder.SpecType) -> str:
     if isinstance(stype, builder.SpecTypeInstance):
-        params = ", ".join([refer_to(ctx, p) for p in stype.parameters])
+        params = [refer_to(ctx, p) for p in stype.parameters]
+
+        if stype.defn_type.is_base_type(builder.BaseTypeName.s_union):
+            if len(stype.parameters) == 1:
+                return f"typing.Union[{params[0]}]"
+            return " | ".join(params)
 
         if stype.defn_type.is_base_type(builder.BaseTypeName.s_readonly_array):
-            assert len(stype.parameters) == 1, "Read Only Array takes one parameter"
-            params = f"{params}, ..."
+            assert len(params) == 1, "Read Only Array takes one parameter"
+            return f"tuple[{params[0]}, ...]"
+
+        if stype.defn_type.is_base_type(builder.BaseTypeName.s_optional):
+            assert len(params) == 1, "Optional only takes one parameter"
+            return f"{params[0]} | None"
 
-        return f"{refer_to(ctx, stype.defn_type)}[{params}]"
+        return f"{refer_to(ctx, stype.defn_type)}[{', '.join(params)}]"
 
     if isinstance(stype, builder.SpecTypeLiteralWrapper):
         return _emit_value(ctx, stype.value_type, stype.value)
@@ -1111,8 +1127,8 @@ def _emit_id_source(*, builder: builder.SpecBuilder, config: PythonConfig) -> No
         return None
     enum_out = io.StringIO()
     enum_out.write(f"{LINT_HEADER}{MODIFY_NOTICE}\n")
-    enum_out.write("from typing import Literal, Union\n")
-    enum_out.write("from pkgs.strenum_compat import StrEnum\n")
+    enum_out.write("import typing\n")
+    enum_out.write("from enum import StrEnum\n")
 
     ctx = TrackingContext()
     # In this context the propername
@@ -1128,11 +1144,11 @@ def _emit_id_source(*, builder: builder.SpecBuilder, config: PythonConfig) -> No
     known_keys = []
     enum_out.write("\nENUM_MAP: dict[str, type[StrEnum]] = {\n")
     for key in sorted(named_enums.keys()):
-        enum_out.write(f'"{key}": {named_enums[key]},\n')
-        known_keys.append(f'Literal["{key}"]')
+        enum_out.write(f'{INDENT}"{key}": {named_enums[key]},\n')
+        known_keys.append(f'"{key}"')
     enum_out.write(f"}}\n{MODIFY_NOTICE}\n")
 
-    enum_out.write(f"\nKnownEnumsType = Union[\n{INDENT}")
+    enum_out.write(f"\nKnownEnumsType = typing.Literal[\n{INDENT}")
     enum_out.write(f",\n{INDENT}".join(known_keys))
     enum_out.write(f"\n]\n{MODIFY_NOTICE}\n")
 

pkgs/type_spec/emit_typescript.py

@@ -2,6 +2,7 @@ import io
 import os
 
 from . import builder, util
+from .builder import EndpointKey, EndpointSpecificPath
 from .config import TypeScriptConfig
 from .emit_io_ts import emit_type_io_ts
 from .emit_typescript_util import (
@@ -46,7 +47,10 @@ def _emit_types(builder: builder.SpecBuilder, config: TypeScriptConfig) -> None:
             and len(namespace.constants) == 0
         ):
             # Try to capture some common incompleteness errors
-            if namespace.endpoint is None or namespace.endpoint.function is None:
+            if namespace.endpoint is None or any(
+                endpoint_specific_path.function is None
+                for endpoint_specific_path in namespace.endpoint.path_per_api_endpoint.values()
+            ):
                 raise Exception(
                     f"Namespace {'/'.join(namespace.path)} is incomplete. It should have an endpoint with function, types, and/or constants"
                 )
@@ -209,12 +213,15 @@ export type Response = DeprecatedResult
 
     """
 
-    endpoint_path_part = (
-        f'"{endpoint.path_root}/{endpoint.path_dirname}/{endpoint.path_basename}",'
-    )
-
-    if has_multiple_endpoints:
+    if not has_multiple_endpoints:
+        default_endpoint_path = endpoint.path_per_api_endpoint[
+            endpoint.default_endpoint_key
+        ]
+        endpoint_path_part = f'"{default_endpoint_path.path_root}/{default_endpoint_path.path_dirname}/{default_endpoint_path.path_basename}",'
+    else:
         path_lookup_map = ""
+        api_endpoint_key: EndpointKey
+        endpoint_specific_path: EndpointSpecificPath
         for (
             api_endpoint_key,
             endpoint_specific_path,

pkgs/type_spec/parts/base.py.prepart

@@ -22,6 +22,8 @@ PureJsonScalar = Union[str, float, bool, None]
 # Regular expressions for identifying ref names and IDs. Ref names should be
 # using this regular expression as a constriant in the database.
 REF_NAME_REGEX = r"^[a-zA-Z0-9_/-]+$"
+REF_NAME_STRICT_REGEX_STRING = "^[a-zA-Z_][a-zA-Z0-9_]*$"
+REF_NAME_STRICT_REGEX = rf"{REF_NAME_STRICT_REGEX_STRING}"
 # Ids matching a strict integer number are converted to integers
 ID_REGEX = r"-?[1-9][0-9]{0,20}"
 

pkgs/type_spec/util.py

@@ -1,12 +1,10 @@
 import json
 import os
 from dataclasses import dataclass
-from typing import TypeVar, Union
+from typing import Union
 
 import regex as re
 
-T = TypeVar("T")
-
 
 def rewrite_file(filename: str, content: str) -> bool:
     os.makedirs(os.path.dirname(filename), exist_ok=True)
@@ -156,7 +154,7 @@ def is_valid_property_name(name: str) -> bool:
     return re_pattern_property_name.match(name) is not None
 
 
-def check_fields(data: dict[str, T], allowed: list[str]) -> None:
+def check_fields[T](data: dict[str, T], allowed: list[str]) -> None:
     for key in data:
         if key not in allowed:
             raise Exception(f"unexpected-field: {key}. Allowed: {allowed}")
@@ -180,7 +178,7 @@ def encode_common_string(value: str) -> str:
     return rep
 
 
-def unused(_arg: T) -> None:
+def unused[T](_arg: T) -> None:
     """
     Identifies that an argument is intended not be used, as opposed to
     simply forgotten, or a remnant. This can happen in patterned calls

pkgs/type_spec/value_spec/__main__.py

@@ -13,7 +13,10 @@ One of the following can be specified on the name of a argument:
 After that you can also specify a `!` indicating the argument may not be null.
 If this is not specified, then a null input on this argument should produce a null output.
 We prefer not to use `!` as we want to encourage null pass-through where possible.
-If null is allowed as a legitimate value, such as in conditionals like `if`, then `!` must be specified.
+
+If null is allowed as a legitimate value, such as in conditionals like `is_null`,
+then `!usenull` must be specified, this distinguishes it from the pass-through case.
+The accepted argument type must accept "None", it is not implied.
 """
 
 import sys
@@ -84,7 +87,7 @@ class Source:
         return self._text[start : self._at]
 
 
-_re_argument_name = re.compile(r"([a-z_]+)(\?|\+)?(!)?:")
+_re_argument_name = re.compile(r"([a-z_]+)(\?|\+)?(!|!usenull)?:")
 
 
 def parse_function_signature(text: str) -> ParsedFunctionSignature:
@@ -103,9 +106,16 @@ def parse_function_signature(text: str) -> ParsedFunctionSignature:
         ref_name = arg_group.group(1)
         is_missing = arg_group.group(2) == "?"
         is_repeating = arg_group.group(2) == "+"
-        pass_null = arg_group.group(3) is None
         type_path = parse_type_str(type_str)
 
+        match arg_group.group(3):
+            case "!":
+                on_null = value_spec_t.OnNull.DISALLOW
+            case "!usenull":
+                on_null = value_spec_t.OnNull.USE
+            case _:
+                on_null = value_spec_t.OnNull.PASS
+
         extant = value_spec_t.ArgumentExtant.REQUIRED
         extant_marker = arg_group.group(2)
         if extant_marker == "?":
@@ -116,7 +126,7 @@ def parse_function_signature(text: str) -> ParsedFunctionSignature:
         arguments.append(
             ParsedFunctionArgument(
                 ref_name=ref_name,
-                pass_null=pass_null,
+                on_null=on_null,
                 extant=extant,
                 type_path=type_path,
             )
@@ -208,7 +218,7 @@ def main() -> None:
                         name=arg_name,
                         description=arg_description,
                         type=convert_to_value_spec_type(in_argument.type_path),
-                        pass_null=in_argument.pass_null,
+                        on_null=in_argument.on_null,
                         extant=in_argument.extant,
                     )
                 )

pkgs/type_spec/value_spec/emit_python.py

@@ -70,7 +70,7 @@ def _emit_function_wrapper(function: value_spec_t.Function) -> str:
         else:
             python_type = _emit_python_type(argument.type)
             if (
-                argument.pass_null
+                argument.on_null == value_spec_t.OnNull.PASS
                 or argument.extant == value_spec_t.ArgumentExtant.MISSING
             ):
                 python_type += " | None"
@@ -189,7 +189,10 @@ def _emit_argument(argument: value_spec_t.FunctionArgument, indent: str) -> str:
     out.write(
         f"{sub_indent}description={encode_common_string(argument.description)},\n"
     )
-    out.write(f"{sub_indent}pass_null={str(argument.pass_null)},\n")
+    # Quick enum emit since we have only one such type here
+    out.write(
+        f"{sub_indent}on_null=value_spec_t.OnNull.{str(argument.on_null).upper()},\n"
+    )
     out.write(
         f"{sub_indent}extant=value_spec_t.ArgumentExtant.{argument.extant.name},\n"
     )

pkgs/type_spec/value_spec/types.py

@@ -8,7 +8,7 @@ from ..util import ParsedTypePath
 @dataclass(kw_only=True, frozen=True)
 class ParsedFunctionArgument:
     ref_name: str
-    pass_null: bool
+    on_null: value_spec_t.OnNull
     extant: value_spec_t.ArgumentExtant
     type_path: ParsedTypePath
 

uncountable/core/client.py

@@ -50,7 +50,7 @@ class HTTPGetRequest(HTTPRequestBase):
 @dataclass(kw_only=True)
 class HTTPPostRequest(HTTPRequestBase):
     method = EndpointMethod.POST
-    body: typing.Union[str, dict[str, str]]
+    body: str | dict[str, str]
 
 
 HTTPRequest = HTTPPostRequest | HTTPGetRequest
@@ -61,7 +61,7 @@ class ClientConfig(ClientConfigOptions):
     transform_request: typing.Callable[[requests.Request], requests.Request] | None = (
         None
     )
-    logger: typing.Optional[Logger] = None
+    logger: Logger | None = None
 
 
 OAUTH_REFRESH_WINDOW_SECONDS = 60 * 5
@@ -197,9 +197,10 @@ class Client(ClientMethods):
             logger=self._cfg.logger,
         )
 
-    def _get_response_json(
-        self, response: requests.Response, request_id: str
-    ) -> dict[str, JsonValue]:
+    @classmethod
+    def _validate_response_status(
+        cls, response: requests.Response, request_id: str
+    ) -> None:
         if response.status_code < 200 or response.status_code > 299:
             extra_details: dict[str, JsonValue] | None = None
             try:
@@ -214,6 +215,11 @@ class Client(ClientMethods):
                 extra_details=extra_details,
                 request_id=request_id,
             )
+
+    def _get_response_json(
+        self, response: requests.Response, request_id: str
+    ) -> dict[str, JsonValue]:
+        self._validate_response_status(response, request_id)
         try:
             return typing.cast(dict[str, JsonValue], response.json())
         except JSONDecodeError as e:
@@ -327,7 +333,7 @@ class Client(ClientMethods):
             case _:
                 raise ValueError(f"unsupported request method: {method}")
 
-    def _get_downloaded_filename(self, *, cd: typing.Optional[str]) -> str:
+    def _get_downloaded_filename(self, *, cd: str | None) -> str:
         if not cd:
             return "Unknown"
 
@@ -361,6 +367,8 @@ class Client(ClientMethods):
         assert isinstance(http_request, HTTPGetRequest)
         request.params = http_request.query_params
         response = self._send_request(request)
+        self._validate_response_status(response, request_id)
+
         content = response.content
         content_disposition = response.headers.get("Content-Disposition", None)
         return [

uncountable/core/file_upload.py

@@ -111,6 +111,11 @@ class FileUploader:
                 if self._logger is not None:
                     self._logger.log_info("Uploading file", attributes=attributes)
                 with file_upload_data(file_upload) as file_bytes:
+                    if file_bytes.bytes_data.read(1) == b"":
+                        raise UploadFailed(
+                            f"Failed to upload empty file: {file_bytes.name}"
+                        )
+                    file_bytes.bytes_data.seek(0)
                     location = await aiotus.upload(
                         creation_url,
                         file_bytes.bytes_data,

uncountable/integration/job.py

@@ -28,7 +28,7 @@ CronJobArguments = JobArguments
 PT = typing.TypeVar("PT")
 
 
-class Job(ABC, typing.Generic[PT]):
+class Job[PT](ABC):
     _unc_job_registered: bool = False
 
     @property
@@ -62,7 +62,7 @@ class CronJob(Job):
 WPT = typing.TypeVar("WPT")
 
 
-class WebhookJob(Job[webhook_job_t.WebhookEventPayload], typing.Generic[WPT]):
+class WebhookJob[WPT](Job[webhook_job_t.WebhookEventPayload]):
     @property
     def payload_type(self) -> type[webhook_job_t.WebhookEventPayload]:
         return webhook_job_t.WebhookEventPayload

uncountable/integration/queue_runner/command_server/types.py

@@ -14,7 +14,7 @@ RT = typing.TypeVar("RT")
 
 
 @dataclass(kw_only=True)
-class CommandBase(typing.Generic[RT]):
+class CommandBase[RT]:
     type: CommandType
     response_queue: asyncio.Queue[RT]
 

uncountable/integration/server.py

@@ -1,7 +1,7 @@
 import signal
 from dataclasses import asdict
 from types import TracebackType
-from typing import Optional, assert_never
+from typing import assert_never
 
 from apscheduler.executors.pool import ThreadPoolExecutor
 from apscheduler.jobstores.sqlalchemy import SQLAlchemyJobStore
@@ -110,8 +110,8 @@ class IntegrationServer:
 
     def __exit__(
         self,
-        exc_type: Optional[type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
     ) -> None:
         self._stop_apscheduler()

uncountable/types/__init__.py

@@ -1,5 +1,4 @@
 # DO NOT MODIFY -- This file is generated by type_spec
-# flake8: noqa: F821
 # ruff: noqa: E402 Q003
 # fmt: off
 # isort: skip_file

uncountable/types/api/batch/execute_batch.py

@@ -1,5 +1,4 @@
 # DO NOT MODIFY -- This file is generated by type_spec
-# flake8: noqa: F821
 # ruff: noqa: E402 Q003
 # fmt: off
 # isort: skip_file
@@ -7,7 +6,7 @@ from __future__ import annotations
 import typing  # noqa: F401
 import datetime  # noqa: F401
 from decimal import Decimal  # noqa: F401
-from pkgs.strenum_compat import StrEnum
+from enum import StrEnum
 import dataclasses
 from pkgs.serialization import serial_class
 from ... import base_t

uncountable/types/api/batch/execute_batch_load_async.py

@@ -1,5 +1,4 @@
 # DO NOT MODIFY -- This file is generated by type_spec
-# flake8: noqa: F821
 # ruff: noqa: E402 Q003
 # fmt: off
 # isort: skip_file

uncountable/types/api/chemical/convert_chemical_formats.py

@@ -1,5 +1,4 @@
 # DO NOT MODIFY -- This file is generated by type_spec
-# flake8: noqa: F821
 # ruff: noqa: E402 Q003
 # fmt: off
 # isort: skip_file

uncountable/types/api/entity/create_entities.py

@@ -1,5 +1,4 @@
 # DO NOT MODIFY -- This file is generated by type_spec
-# flake8: noqa: F821
 # ruff: noqa: E402 Q003
 # fmt: off
 # isort: skip_file
@@ -32,7 +31,7 @@ ENDPOINT_PATH = "api/external/entity/external_create_entities"
 )
 @dataclasses.dataclass(kw_only=True)
 class EntityToCreate:
-    field_values: typing.Optional[list[field_values_t.FieldRefNameValue]] | None = None
+    field_values: list[field_values_t.FieldRefNameValue] | None = None
 
 
 # DO NOT MODIFY -- This file is generated by type_spec

uncountable/types/api/entity/create_entity.py

@@ -1,5 +1,4 @@
 # DO NOT MODIFY -- This file is generated by type_spec
-# flake8: noqa: F821
 # ruff: noqa: E402 Q003
 # fmt: off
 # isort: skip_file
@@ -35,7 +34,7 @@ ENDPOINT_PATH = "api/external/entity/external_create_entity"
 class EntityFieldInitialValue:
     field_ref_name: str
     value: base_t.JsonValue
-    row_index: typing.Optional[int] | None = None
+    row_index: int | None = None
 
 
 # DO NOT MODIFY -- This file is generated by type_spec
@@ -47,7 +46,7 @@ class Arguments:
     entity_type: entity_t.LimitedEntityType
     definition_id: base_t.ObjectId | None = None
     definition_key: identifier_t.IdentifierKey | None = None
-    field_values: typing.Optional[list[field_values_t.FieldRefNameValue]] | None = None
+    field_values: list[field_values_t.FieldRefNameValue] | None = None
 
 
 # DO NOT MODIFY -- This file is generated by type_spec

uncountable/types/api/entity/get_entities_data.py

@@ -1,5 +1,4 @@
 # DO NOT MODIFY -- This file is generated by type_spec
-# flake8: noqa: F821
 # ruff: noqa: E402 Q003
 # fmt: off
 # isort: skip_file