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

pkgs/filesystem_utils/file_type_utils.py

@@ -1,7 +1,7 @@
 import os
 from dataclasses import dataclass
 from io import BytesIO
-from typing import Optional, Union
+from typing import Union
 
 import paramiko
 from azure.core.credentials import (
@@ -17,9 +17,9 @@ class FileObjectData:
     file_data: bytes
     file_IO: BytesIO
     filename: str
-    filepath: Optional[str] = None
-    mime_type: Optional[str] = None
-    metadata: Optional[dict[str, str]] = None
+    filepath: str | None = None
+    mime_type: str | None = None
+    metadata: dict[str, str] | None = None
 
 
 @dataclass
@@ -39,7 +39,7 @@ class FileSystemFileReference:
 class RemoteObjectReference:
     file_id: str
     mime_type: str
-    filename: Optional[str] = None
+    filename: str | None = None
 
     @property
     def is_dir(self) -> bool:
@@ -63,7 +63,7 @@ class FileSystemSFTPConfig:
     pem_path: str | None
     pem_key: paramiko.RSAKey | None = None
     password: str | None = None
-    valid_extensions: Optional[tuple[str]] = None
+    valid_extensions: tuple[str] | None = None
     recursive: bool = True
 
 
@@ -71,10 +71,10 @@ class FileSystemSFTPConfig:
 class FileSystemS3Config:
     endpoint_url: str
     bucket_name: str
-    region_name: Optional[str]
-    access_key_id: Optional[str]
-    secret_access_key: Optional[str]
-    session_token: Optional[str]
+    region_name: str | None
+    access_key_id: str | None
+    secret_access_key: str | None
+    session_token: str | None
 
 
 @dataclass(kw_only=True)

pkgs/serialization/annotation.py

@@ -6,7 +6,7 @@ T = typing.TypeVar("T")
 
 @dataclasses.dataclass(kw_only=True, frozen=True, eq=True)
 class SerialBase:
-    named_type_path: typing.Optional[str] = None
+    named_type_path: str | None = None
     # Indicates this type is allowed in dynamic lookups, such as via a named_type_path
     # This isn't meant to be limting, but to catalog all the types where we need it
     is_dynamic_allowed: bool = False
@@ -16,7 +16,7 @@ class SerialBase:
     from_decorator: bool = False
 
 
-def get_serial_annotation(parsed_type: type[T]) -> SerialBase | None:
+def get_serial_annotation[T](parsed_type: type[T]) -> SerialBase | None:
     if not hasattr(parsed_type, "__metadata__"):
         return None
     metadata = parsed_type.__metadata__  # type:ignore[attr-defined]
@@ -28,13 +28,13 @@ def get_serial_annotation(parsed_type: type[T]) -> SerialBase | None:
     return serial
 
 
-class SerialInspector(typing.Generic[T]):
+class SerialInspector[T]:
     def __init__(self, parsed_type: type[T], serial_base: SerialBase) -> None:
         self._parsed_type = parsed_type
         self._serial_base = serial_base
 
     @property
-    def named_type_path(self) -> typing.Optional[str]:
+    def named_type_path(self) -> str | None:
         return self._serial_base.named_type_path
 
     @property
@@ -53,7 +53,7 @@ class SerialInspector(typing.Generic[T]):
         return self._serial_base.is_dynamic_allowed
 
 
-def unwrap_annotated(parsed_type: type[T]) -> type[T]:
+def unwrap_annotated[T](parsed_type: type[T]) -> type[T]:
     """
     If the type is an annotated type then return the origin of it.
     Otherwise return the original type.

pkgs/serialization/missing_sentry.py

@@ -26,5 +26,5 @@ MISSING_SENTRY = MissingSentryType()
 MissingType = Union[MissingSentryType, ClassT]
 
 
-def coalesce_missing_sentry(value: MissingType[ClassT]) -> Optional[ClassT]:
+def coalesce_missing_sentry[ClassT](value: MissingType[ClassT]) -> ClassT | None:
     return None if isinstance(value, MissingSentryType) else value

pkgs/serialization/serial_alias.py

@@ -16,7 +16,7 @@ class _SerialAlias(SerialBase):
 
 def serial_alias_annotation(
     *,
-    named_type_path: typing.Optional[str] = None,
+    named_type_path: str | None = None,
     is_dynamic_allowed: bool = False,
 ) -> _SerialAlias:
     return _SerialAlias(
@@ -26,7 +26,7 @@ def serial_alias_annotation(
     )
 
 
-def _get_serial_alias(parsed_type: type[T]) -> _SerialAlias | None:
+def _get_serial_alias[T](parsed_type: type[T]) -> _SerialAlias | None:
     serial = get_serial_annotation(parsed_type)
     if not isinstance(serial, _SerialAlias):
         return None
@@ -39,7 +39,7 @@ class SerialAliasInspector(SerialInspector[T]):
         self._serial_alias = serial_alias
 
 
-def get_serial_alias_data(parsed_type: type[T]) -> SerialAliasInspector[T] | None:
+def get_serial_alias_data[T](parsed_type: type[T]) -> SerialAliasInspector[T] | None:
     serial = _get_serial_alias(parsed_type)
     if serial is None:
         return None

pkgs/serialization/serial_class.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import dataclasses
 from collections.abc import Callable
 from enum import StrEnum
-from typing import Any, Optional, TypeVar, cast
+from typing import Any, TypeVar, cast
 
 from .annotation import SerialBase, SerialInspector
 
@@ -16,7 +16,7 @@ class _SerialClassData(SerialBase):
     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
+    named_type_path: str | None = None
 
 
 EMPTY_SERIAL_CLASS_DATA = _SerialClassData()
@@ -24,11 +24,11 @@ EMPTY_SERIAL_CLASS_DATA = _SerialClassData()
 
 def serial_class(
     *,
-    unconverted_keys: Optional[set[str]] = None,
-    unconverted_values: Optional[set[str]] = None,
-    to_string_values: Optional[set[str]] = None,
-    parse_require: Optional[set[str]] = None,
-    named_type_path: Optional[str] = None,
+    unconverted_keys: set[str] | None = None,
+    unconverted_values: set[str] | None = None,
+    to_string_values: set[str] | None = None,
+    parse_require: set[str] | None = None,
+    named_type_path: str | None = None,
     is_dynamic_allowed: bool = False,
 ) -> Callable[[_ClassT], _ClassT]:
     """
@@ -119,7 +119,7 @@ def get_merged_serial_class_data(type_class: type[Any]) -> _SerialClassData | No
     return base_class_data
 
 
-def get_serial_class_data(
+def get_serial_class_data[_ClassT](
     type_class: type[_ClassT],
 ) -> SerialClassDataInspector[_ClassT]:
     return SerialClassDataInspector(
@@ -134,7 +134,7 @@ class _SerialStringEnumData:
 
 
 def serial_string_enum(
-    *, labels: Optional[dict[str, str]] = None, deprecated: Optional[set[str]] = None
+    *, labels: dict[str, str] | None = None, deprecated: set[str] | None = None
 ) -> Callable[[_ClassT], _ClassT]:
     """
     A decorator for enums to provide serialization data, including labels.
@@ -153,7 +153,7 @@ class SerialStringEnumInspector:
     def __init__(self, current: _SerialStringEnumData) -> None:
         self.current = current
 
-    def get_label(self, value: str) -> Optional[str]:
+    def get_label(self, value: str) -> str | None:
         return self.current.labels.get(value)
 
     def get_deprecated(self, value: str) -> bool:

pkgs/serialization/serial_generic.py

@@ -6,7 +6,7 @@ from .serial_class import get_merged_serial_class_data
 T = typing.TypeVar("T")
 
 
-def get_serial_data(parsed_type: type[T]) -> SerialInspector[T] | None:
+def get_serial_data[T](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)

pkgs/serialization/serial_union.py

@@ -6,7 +6,7 @@ from .annotation import SerialBase, SerialInspector, get_serial_annotation
 T = typing.TypeVar("T")
 
 
-class IdentityHashWrapper(typing.Generic[T]):
+class IdentityHashWrapper[T]:
     """This allows unhashable types to be used in the SerialUnion, like dict.
     Since we have only one copy of the types themselves, we rely on
     object identity for the hashing."""
@@ -27,15 +27,15 @@ class _SerialUnion(SerialBase):
 
     # If specified, indicates the Union has a discriminator which should be used to
     # determine which type to parse.
-    discriminator: typing.Optional[str] = None
-    discriminator_map: typing.Optional[IdentityHashWrapper[dict[str, type]]] = None
+    discriminator: str | None = None
+    discriminator_map: IdentityHashWrapper[dict[str, type]] | None = None
 
 
 def serial_union_annotation(
     *,
-    discriminator: typing.Optional[str] = None,
-    discriminator_map: typing.Optional[dict[str, type]] = None,
-    named_type_path: typing.Optional[str] = None,
+    discriminator: str | None = None,
+    discriminator_map: dict[str, type] | None = None,
+    named_type_path: str | None = None,
     is_dynamic_allowed: bool = False,
 ) -> _SerialUnion:
     return _SerialUnion(
@@ -49,7 +49,7 @@ def serial_union_annotation(
     )
 
 
-def _get_serial_union(parsed_type: type[T]) -> _SerialUnion | None:
+def _get_serial_union[T](parsed_type: type[T]) -> _SerialUnion | None:
     serial = get_serial_annotation(parsed_type)
     if not isinstance(serial, _SerialUnion):
         return None
@@ -66,17 +66,17 @@ class SerialClassInspector(SerialInspector[T]):
         return typing.get_args(self._parsed_type)[0]  # type:ignore[no-any-return]
 
     @property
-    def discriminator(self) -> typing.Optional[str]:
+    def discriminator(self) -> str | None:
         return self._serial_union.discriminator
 
     @property
-    def discriminator_map(self) -> typing.Optional[dict[str, type]]:
+    def discriminator_map(self) -> dict[str, type] | None:
         if self._serial_union.discriminator_map is None:
             return None
         return self._serial_union.discriminator_map.inner
 
 
-def get_serial_union_data(parsed_type: type[T]) -> SerialClassInspector[T] | None:
+def get_serial_union_data[T](parsed_type: type[T]) -> SerialClassInspector[T] | None:
     serial = _get_serial_union(parsed_type)
     if serial is None:
         return None

pkgs/serialization_util/__init__.py

@@ -2,6 +2,7 @@ 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 (
+    JsonValue,
     serialize_for_api,
     serialize_for_storage,
     serialize_for_storage_dict,
@@ -14,4 +15,5 @@ __all__: list[str] = [
     "serialize_for_storage_dict",
     "iterate_fields",
     "dict_fields",
+    "JsonValue",
 ]

pkgs/serialization_util/serialization_helpers.py

@@ -12,7 +12,6 @@ from typing import (
     Any,
     ClassVar,
     Protocol,
-    TypeVar,
     Union,
     overload,
 )
@@ -34,14 +33,12 @@ if TYPE_CHECKING:
 else:
     JsonValue = Union[JsonScalar, dict[str, Any], list[Any]]
 
-T = TypeVar("T")
-
 
 class Dataclass(Protocol):
     __dataclass_fields__: ClassVar[dict]  # type: ignore[type-arg,unused-ignore]
 
 
-def identity(x: T) -> T:
+def identity[T](x: T) -> T:
     return x
 
 

pkgs/type_spec/actions_registry/__main__.py

@@ -6,7 +6,6 @@ import os
 import sys
 from collections import defaultdict
 from dataclasses import dataclass
-from typing import TypeVar
 
 from main.base.types import actions_registry_t
 from pkgs.type_spec import builder
@@ -22,9 +21,6 @@ key_short_description = "short_description"
 key_description = "description"
 
 
-TypeT = TypeVar("TypeT")
-
-
 class InvalidSpecException(Exception):
     pass
 

pkgs/type_spec/builder.py

@@ -10,12 +10,13 @@ import re
 from collections import defaultdict
 from dataclasses import MISSING, dataclass
 from enum import Enum, StrEnum, auto
-from typing import Any, Optional, Self
+from typing import Any, Self
 
 from . import util
 from .util import parse_type_str, unused
 
 RawDict = dict[Any, Any]
+EndpointKey = str
 
 
 class StabilityLevel(StrEnum):
@@ -47,7 +48,7 @@ class PropertyConvertValue(StrEnum):
 @dataclass
 class SpecProperty:
     name: str
-    label: Optional[str]
+    label: str | None
     spec_type: SpecType
     extant: PropertyExtant
     convert_value: PropertyConvertValue
@@ -255,7 +256,7 @@ class SpecTypeLiteralWrapper(SpecType):
         return [self.value_type]
 
 
-def unwrap_literal_type(stype: SpecType) -> Optional[SpecTypeLiteralWrapper]:
+def unwrap_literal_type(stype: SpecType) -> SpecTypeLiteralWrapper | None:
     if isinstance(stype, SpecTypeInstance) and stype.defn_type.is_base_type(
         BaseTypeName.s_literal
     ):
@@ -283,7 +284,7 @@ class SpecTypeDefn(SpecType):
     ) -> None:
         self.namespace = namespace
         self.name = name
-        self.label: Optional[str] = None
+        self.label: str | None = None
 
         self.is_predefined = is_predefined
         self.name_case = NameCase.convert
@@ -455,7 +456,7 @@ class SpecTypeGenericParameter(SpecType):
 
 
 class SpecTypeDefnObject(SpecTypeDefn):
-    base: Optional[SpecTypeDefnObject]
+    base: SpecTypeDefnObject | None
     parameters: list[str]
 
     def __init__(
@@ -463,7 +464,7 @@ class SpecTypeDefnObject(SpecTypeDefn):
         namespace: SpecNamespace,
         name: str,
         *,
-        parameters: Optional[list[str]] = None,
+        parameters: list[str] | None = None,
         is_base: bool = False,
         is_predefined: bool = False,
         is_hashable: bool = False,
@@ -480,7 +481,7 @@ class SpecTypeDefnObject(SpecTypeDefn):
         self.parameters = parameters if parameters is not None else []
         self.is_hashable = is_hashable
         self.base = None
-        self.properties: Optional[dict[str, SpecProperty]] = None
+        self.properties: dict[str, SpecProperty] | None = None
         self._kw_only: bool = True
         self.desc: str | None = None
 
@@ -662,7 +663,7 @@ class SpecTypeDefnExternal(SpecTypeDefn):
 class StringEnumEntry:
     name: str
     value: str
-    label: Optional[str] = None
+    label: str | None = None
     deprecated: bool = False
 
 
@@ -678,7 +679,7 @@ class SpecTypeDefnStringEnum(SpecTypeDefn):
         )
         self.values: dict[str, StringEnumEntry] = {}
         self.desc: str | None = None
-        self.sql_type_name: Optional[str] = None
+        self.sql_type_name: str | None = None
         self.emit_id_source = False
         self.source_enums: list[SpecType] = []
 
@@ -810,13 +811,13 @@ RE_ENDPOINT_ROOT = re.compile(r"\${([_a-z]+)}")
 
 @dataclass(kw_only=True, frozen=True)
 class _EndpointPathDetails:
-    root: str
+    root: EndpointKey
     root_path: str
     resolved_path: str
 
 
 def _resolve_endpoint_path(
-    path: str, api_endpoints: dict[str, str]
+    path: str, api_endpoints: dict[EndpointKey, str]
 ) -> _EndpointPathDetails:
     root_path_source = path.split("/")[0]
     root_match = RE_ENDPOINT_ROOT.fullmatch(root_path_source)
@@ -840,19 +841,59 @@ class EndpointEmitType(StrEnum):
     EMIT_NOTHING = "emit_nothing"
 
 
-class SpecEndpoint:
-    method: RouteMethod
-    root: str
+@dataclass(kw_only=True, frozen=True)
+class EndpointSpecificPath:
+    root: EndpointKey
     path_root: str
     path_dirname: str
     path_basename: str
+    function: str | None
+
+
+def parse_endpoint_specific_path(
+    builder: SpecBuilder,
+    data_per_endpoint: RawDict | None,
+) -> EndpointSpecificPath | None:
+    if data_per_endpoint is None:
+        return None
+    util.check_fields(
+        data_per_endpoint,
+        [
+            "path",
+            "function",
+        ],
+    )
+
+    if "path" not in data_per_endpoint or data_per_endpoint["path"] is None:
+        return None
+
+    path = data_per_endpoint["path"].split("/")
+
+    assert len(path) > 1, "invalid-endpoint-path"
+
+    path_details = _resolve_endpoint_path(
+        data_per_endpoint["path"], builder.api_endpoints
+    )
+
+    result = EndpointSpecificPath(
+        function=data_per_endpoint.get("function"),
+        path_dirname="/".join(path[1:-1]),
+        path_basename=path[-1],
+        root=path_details.root,
+        path_root=path_details.root_path,
+    )
+
+    return result
+
+
+class SpecEndpoint:
+    method: RouteMethod
     data_loader: bool
     is_sdk: EndpointEmitType
     is_beta: bool
     stability_level: StabilityLevel | None
     # Don't emit TypeScript endpoint code
     suppress_ts: bool
-    function: Optional[str]
     async_batch_path: str | None = None
     result_type: ResultType = ResultType.json
     has_attachment: bool = False
@@ -860,6 +901,10 @@ class SpecEndpoint:
     account_type: str | None
     route_group: str | None
 
+    # function, path details per api endpoint
+    path_per_api_endpoint: dict[str, EndpointSpecificPath]
+    default_endpoint_key: EndpointKey
+
     is_external: bool = False
 
     def __init__(self) -> None:
@@ -885,18 +930,11 @@ class SpecEndpoint:
                 "has_attachment",
                 "account_type",
                 "route_group",
-            ],
+            ]
+            + list(builder.api_endpoints.keys()),
         )
         self.method = RouteMethod(data["method"])
 
-        path = data["path"].split("/")
-
-        assert len(path) > 1, "invalid-endpoint-path"
-
-        # handle ${external} in the same way we handle ${materials} for now
-        self.path_dirname = "/".join(path[1:-1])
-        self.path_basename = path[-1]
-
         data_loader = data.get("data_loader", False)
         assert isinstance(data_loader, bool)
         self.data_loader = data_loader
@@ -944,29 +982,70 @@ class SpecEndpoint:
             assert isinstance(async_batch_path, str)
             self.async_batch_path = async_batch_path
 
-        self.function = data.get("function")
-
         suppress_ts = data.get("suppress_ts", False)
         assert isinstance(suppress_ts, bool)
         self.suppress_ts = suppress_ts
 
         self.result_type = ResultType(data.get("result_type", ResultType.json.value))
-
-        path_details = _resolve_endpoint_path(data["path"], builder.api_endpoints)
-        self.root = path_details.root
-        self.path_root = path_details.root_path
+        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:
+            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.default_endpoint_key: default_endpoint_path,
+            }
+        else:
+            self.path_per_api_endpoint = {}
+            shared_function_name = None
+            for endpoint_key in builder.api_endpoints:
+                endpoint_specific_path = parse_endpoint_specific_path(
+                    builder,
+                    data.get(endpoint_key),
+                )
+                if endpoint_specific_path is not None:
+                    self.path_per_api_endpoint[endpoint_key] = endpoint_specific_path
+                    if endpoint_specific_path.function is not None:
+                        fn_name = endpoint_specific_path.function.split(".")[-1]
+                        if shared_function_name is None:
+                            shared_function_name = fn_name
+                        assert shared_function_name == fn_name
+
+            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")
+
+        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.has_attachment = data.get("has_attachment", False)
+        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: {path}"
+            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(
@@ -1079,14 +1158,14 @@ class SpecNamespace:
     ):
         self.types: dict[str, SpecTypeDefn] = {}
         self.constants: dict[str, SpecConstant] = {}
-        self.endpoint: Optional[SpecEndpoint] = None
+        self.endpoint: SpecEndpoint | None = None
         self.emit_io_ts = False
         self.emit_type_info = False
         self.derive_types_from_io_ts = False
-        self._imports: Optional[list[str]] = None
+        self._imports: list[str] | None = None
         self.path = name.split(".")
         self.name = self.path[-1]
-        self._order: Optional[int] = None
+        self._order: int | None = None
 
     def _update_order(self, builder: SpecBuilder, recurse: int = 0) -> int:
         if self._order is not None:
@@ -1241,7 +1320,9 @@ class NameDataPair:
 
 
 class SpecBuilder:
-    def __init__(self, *, api_endpoints: dict[str, str], top_namespace: str) -> None:
+    def __init__(
+        self, *, api_endpoints: dict[EndpointKey, str], top_namespace: str
+    ) -> None:
         self.top_namespace = top_namespace
         self.where: list[str] = []
         self.namespaces = {}
@@ -1339,7 +1420,7 @@ class SpecBuilder:
         self,
         path: util.ParsedTypePath,
         namespace: SpecNamespace,
-        scope: Optional[SpecTypeDefn] = None,
+        scope: SpecTypeDefn | None = None,
         top: bool = False,
     ) -> SpecType:
         """
@@ -1420,7 +1501,7 @@ class SpecBuilder:
         )
 
     def parse_type(
-        self, namespace: SpecNamespace, spec: str, scope: Optional[SpecTypeDefn] = None
+        self, namespace: SpecNamespace, spec: str, scope: SpecTypeDefn | None = None
     ) -> SpecType:
         self.push_where(spec)
         parsed_type = util.parse_type_str(spec)

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
 
@@ -34,6 +34,9 @@ class TypeScriptConfig(BaseLanguageConfig):
     routes_output: str  # folder for generate route files will be located.
     type_info_output: str  # folder for generated type info files
     id_source_output: str | None = None  # folder for emitted id source maps.
+    endpoint_to_frontend_app_type: dict[
+        str, str
+    ]  # map from api_endpoint to frontend app type
 
     def __post_init__(self: Self) -> None:
         self.routes_output = self.routes_output
@@ -43,6 +46,11 @@ class TypeScriptConfig(BaseLanguageConfig):
             if self.id_source_output is not None
             else None
         )
+        self.endpoint_to_frontend_app_type = _parse_string_lookup(
+            "typescript_endpoint_to_frontend_app_type",
+            self.endpoint_to_frontend_app_type,
+            lambda x: x,
+        )
 
 
 @dataclass(kw_only=True)
@@ -95,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)