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

pkgs/type_spec/emit_python.py

@@ -1,17 +1,20 @@
+import dataclasses
 import io
 import os
-from dataclasses import dataclass, field
 from decimal import Decimal
-from typing import Any, Optional, Set
+from typing import Any
 
 from . import builder, util
+from .builder import EndpointEmitType
 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\n# fmt: off\n# isort: skip_file\n"
+LINT_HEADER = (
+    "# flake8: noqa: F821\n# 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"""
@@ -21,29 +24,44 @@ __all__: list[str] = [
 """
 END_ALL_EXPORTS = "]\n"
 
+ASYNC_BATCH_TYPE_NAMESPACE = builder.SpecNamespace(name="async_batch")
+ASYNC_BATCH_REQUEST_PATH_STYPE = builder.SpecTypeDefnStringEnum(
+    namespace=ASYNC_BATCH_TYPE_NAMESPACE, name="AsyncBatchRequestPath"
+)
+ASYNC_BATCH_REQUEST_STYPE = builder.SpecTypeDefnObject(
+    namespace=ASYNC_BATCH_TYPE_NAMESPACE, name="AsyncBatchRequest"
+)
+QUEUED_BATCH_REQUEST_STYPE = builder.SpecTypeDefnObject(
+    namespace=ASYNC_BATCH_TYPE_NAMESPACE, name="QueuedAsyncBatchRequest"
+)
 
-@dataclass(kw_only=True)
+
+@dataclasses.dataclass(kw_only=True)
 class TrackingContext:
-    namespace: Optional[builder.SpecNamespace] = None
-    namespaces: Set[builder.SpecNamespace] = field(default_factory=set)
-    names: Set[str] = field(default_factory=set)
+    namespace: builder.SpecNamespace | None = None
+    namespaces: set[builder.SpecNamespace] = dataclasses.field(default_factory=set)
+    names: set[str] = dataclasses.field(default_factory=set)
 
     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_serial_alias: bool = False
     use_missing: bool = False
     use_opaque_key: bool = False
 
 
-@dataclass(kw_only=True)
+@dataclasses.dataclass(kw_only=True)
 class Context(TrackingContext):
     out: io.StringIO
     namespace: builder.SpecNamespace
+    builder: builder.SpecBuilder
 
 
 def _resolve_namespace_name(namespace: builder.SpecNamespace) -> str:
-    return namespace.name
+    if len(namespace.path) > 1:
+        return namespace.name
+    return f"{namespace.name}_t"
 
 
 def _resolve_namespace_ref(namespace: builder.SpecNamespace) -> str:
@@ -119,6 +137,9 @@ def _emit_value(ctx: TrackingContext, stype: builder.SpecType, value: Any) -> st
         # Note that decimal requires the `!decimal 123.12` style notation in the YAML
         # file since PyYaml parses numbers as float, unfortuantely
         assert isinstance(value, (Decimal, int))
+        if isinstance(value, int):
+            # skip quotes for integers
+            return f"Decimal({value})"
         return f'Decimal("{value}")'
     elif isinstance(stype, builder.SpecTypeInstance):
         if stype.defn_type.is_base_type(builder.BaseTypeName.s_list):
@@ -191,6 +212,7 @@ def emit_python(builder: builder.SpecBuilder, *, config: PythonConfig) -> None:
     _emit_api_stubs(builder=builder, config=config)
     _emit_api_argument_lookup(builder=builder, config=config)
     _emit_client_class(spec_builder=builder, config=config)
+    _emit_async_batch_processor(spec_builder=builder, config=config)
 
 
 def _emit_types_imports(*, out: io.StringIO, ctx: Context) -> None:
@@ -201,9 +223,12 @@ def _emit_types_imports(*, out: io.StringIO, ctx: Context) -> None:
     if ctx.use_enum:
         out.write("from pkgs.strenum_compat import StrEnum\n")
     if ctx.use_dataclass:
-        out.write("from dataclasses import dataclass\n")
-    if ctx.use_serial_class:
+        out.write("import dataclasses\n")
         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:
@@ -220,7 +245,7 @@ def _emit_types(*, builder: builder.SpecBuilder, config: PythonConfig) -> None:
     exports_out = io.StringIO()
     exports_out.write(START_ALL_EXPORTS)
 
-    all_dirs: Set[str] = set()
+    all_dirs: set[str] = set()
 
     for namespace in sorted(
         builder.namespaces.values(),
@@ -228,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
@@ -236,6 +261,7 @@ def _emit_types(*, builder: builder.SpecBuilder, config: PythonConfig) -> None:
         ctx = Context(
             out=io.StringIO(),
             namespace=namespace,
+            builder=builder,
         )
 
         _emit_namespace(ctx, namespace)
@@ -274,17 +300,22 @@ def _emit_types(*, builder: builder.SpecBuilder, config: PythonConfig) -> None:
             full.write(f"# === END section from {namespace.name}.part.py ===\n")
 
         basename = "/".join(namespace.path)
-        filename = f"{config.types_output}/{basename}.py"
+        filename = f"{config.types_output}/{basename}{'' if len(namespace.path) > 1 else '_t'}.py"
         util.rewrite_file(filename, full.getvalue())
 
+        # Deprecated SDK support
+        if config.all_named_type_exports and len(namespace.path) == 1:
+            compat_out = _create_sdk_compat_namespace(namespace)
+            compat_filename = f"{config.types_output}/{basename}.py"
+            util.rewrite_file(compat_filename, compat_out.getvalue())
+
         path_to = os.path.dirname(basename)
         while path_to != "":
             all_dirs.add(path_to)
             path_to = os.path.dirname(path_to)
 
-        if len(namespace.path) == 1 or (
-            config.all_named_type_exports and len(namespace.path) > 1
-        ):
+        # Deprecated SDK support
+        if config.all_named_type_exports:
             index_out.write("from ")
             if len(namespace.path) == 1:
                 index_out.write(".")
@@ -313,6 +344,9 @@ def _emit_types(*, builder: builder.SpecBuilder, config: PythonConfig) -> None:
 
 ENDPOINT_METHOD = "ENDPOINT_METHOD"
 ENDPOINT_PATH = "ENDPOINT_PATH"
+# will be removed in Q1 2025 when ENDPOINT_PATH is made api_endpoint-agnostic
+# is used when the API call has multiple endpoints for the one endpoint that isn't equal to the top_namespace
+ENDPOINT_PATH_ALTERNATE = "ENDPOINT_PATH_ALTERNATE"
 
 
 def _emit_namespace(ctx: Context, namespace: builder.SpecNamespace) -> None:
@@ -320,9 +354,20 @@ def _emit_namespace(ctx: Context, namespace: builder.SpecNamespace) -> None:
     if endpoint is not None:
         ctx.out.write("\n")
         ctx.out.write(f'{ENDPOINT_METHOD} = "{endpoint.method.upper()}"\n')
-        ctx.out.write(
-            f'{ENDPOINT_PATH} = "{endpoint.path_root}/{endpoint.path_dirname}/{endpoint.path_basename}"\n'
-        )
+        for endpoint_specific_path in sorted(
+            endpoint.path_per_api_endpoint.values(), key=lambda epf: epf.root
+        ):
+            endpoint_path_name = ENDPOINT_PATH
+
+            if (
+                len(endpoint.path_per_api_endpoint.keys()) > 1
+                and endpoint_specific_path.root != ctx.builder.top_namespace
+            ):
+                endpoint_path_name = ENDPOINT_PATH_ALTERNATE
+                ctx.names.add(ENDPOINT_PATH_ALTERNATE)
+            ctx.out.write(
+                f'{endpoint_path_name} = "{endpoint_specific_path.path_root}/{endpoint_specific_path.path_dirname}/{endpoint_specific_path.path_basename}"\n'
+            )
 
         ctx.names.add(ENDPOINT_METHOD)
         ctx.names.add(ENDPOINT_PATH)
@@ -334,78 +379,243 @@ def _emit_namespace(ctx: Context, namespace: builder.SpecNamespace) -> None:
         _emit_constant(ctx, sconst)
 
 
+def _create_sdk_compat_namespace(namespace: builder.SpecNamespace) -> io.StringIO:
+    compat_out = io.StringIO()
+    compat_out.write(LINT_HEADER)
+    compat_out.write(MODIFY_NOTICE)
+    compat_out.write("# Kept only for SDK backwards compatibility\n")
+
+    # This mostly an prepart import, thus has no high-level knowledge. Since this onl
+    # needs backwards copmatibiltiy from when written we can just hardcode what was there
+    # (only those in __all__ assuming that worked, which it might not)
+    if namespace.name == "base":
+        compat_out.write("""
+from .base_t import JsonScalar as JsonScalar
+from .base_t import JsonValue as JsonValue
+from .base_t import ObjectId as ObjectId
+""")
+    else:
+        for stype in namespace.types.values():
+            compat_out.write(
+                f"from .{namespace.path[-1]}_t import {stype.name} as {stype.name}\n"
+            )
+
+    compat_out.write(MODIFY_NOTICE)
+
+    return compat_out
+
+
 def _validate_supports_handler_generation(
     stype: builder.SpecTypeDefn, name: str, supports_inheritance: bool = False
 ) -> builder.SpecTypeDefnObject:
-    assert isinstance(
-        stype, builder.SpecTypeDefnObject
-    ), f"External api {name} must be an object"
+    assert isinstance(stype, builder.SpecTypeDefnObject), (
+        f"External api {name} must be an object"
+    )
     if not supports_inheritance:
-        assert (
-            stype.base is None or stype.base.is_base
-        ), f"Inheritance not supported in external api {name}"
+        assert stype.base is None or stype.base.is_base, (
+            f"Inheritance not supported in external api {name}"
+        )
     return stype
 
 
-def _emit_endpoint_invocation_function(
-    ctx: Context, namespace: builder.SpecNamespace
+def _emit_endpoint_invocation_docstring(
+    ctx: Context,
+    endpoint: builder.SpecEndpoint,
+    properties: list[builder.SpecProperty],
 ) -> None:
-    endpoint = namespace.endpoint
-    if endpoint is None:
-        return
-    if not endpoint.is_sdk:
+    has_argument_desc = any(prop.desc is not None for prop in properties)
+    has_endpoint_desc = endpoint.desc
+    if not has_argument_desc and not has_endpoint_desc:
         return
 
-    arguments_type = namespace.types["Arguments"]
-    data_type = namespace.types["Data"]
+    FULL_INDENT = INDENT * 2
+    ctx.out.write(FULL_INDENT)
+    ctx.out.write('"""')
 
-    arguments_type = _validate_supports_handler_generation(arguments_type, "arguments")
-    data_type = _validate_supports_handler_generation(
-        data_type, "response", supports_inheritance=True
-    )
+    if endpoint.desc is not None and has_endpoint_desc:
+        ctx.out.write(f"{endpoint.desc}\n")
+        ctx.out.write("\n")
 
-    endpoint_method_stype = builder.SpecTypeDefnObject(
-        namespace=arguments_type.namespace, name=ENDPOINT_METHOD
-    )
-    endpoint_path_stype = builder.SpecTypeDefnObject(
-        namespace=arguments_type.namespace, name=ENDPOINT_PATH
-    )
+    if has_argument_desc:
+        for prop in properties:
+            if prop.desc:
+                ctx.out.write(f"{FULL_INDENT}:param {prop.name}: {prop.desc}\n")
+
+    ctx.out.write(f'{FULL_INDENT}"""\n')
+
+
+def _emit_endpoint_invocation_function_signature(
+    ctx: Context,
+    endpoint: builder.SpecEndpoint,
+    arguments_type: builder.SpecTypeDefnObject,
+    data_type: builder.SpecTypeDefnObject,
+    extra_params: list[builder.SpecProperty] | None = None,
+) -> None:
+    all_arguments = (
+        list(arguments_type.properties.values())
+        if arguments_type.properties is not None
+        else []
+    ) + (extra_params if extra_params is not None else [])
 
-    has_arguments = (
-        arguments_type.properties is not None
-        and len(arguments_type.properties.values()) > 0
-    )
     assert endpoint.function is not None
     function_name = endpoint.function.split(".")[-1]
-    ctx.out.write("\n")
     ctx.out.write(
         f"""
     def {function_name}(
         self,\n"""
     )
-    if has_arguments:
+    if len(all_arguments) > 0:
         ctx.out.write(f"{INDENT}{INDENT}*,\n")
-        _emit_type_properties(
+        _emit_properties(
             ctx=ctx,
-            stype=arguments_type,
+            properties=all_arguments,
             num_indent=2,
             separator=",\n",
             class_out=ctx.out,
         )
     ctx.out.write(f"{INDENT}) -> {refer_to(ctx=ctx, stype=data_type)}:")
-
     ctx.out.write("\n")
-    ctx.out.write(f"{INDENT}{INDENT}args = {refer_to(ctx=ctx, stype=arguments_type)}(")
-    if has_arguments:
-        assert arguments_type.properties is not None
+
+    if len(all_arguments) > 0:
+        _emit_endpoint_invocation_docstring(
+            ctx=ctx, endpoint=endpoint, properties=all_arguments
+        )
+
+
+def _emit_instantiate_type_from_locals(
+    ctx: Context, variable_name: str, variable_type: builder.SpecTypeDefnObject
+) -> None:
+    ctx.out.write(
+        f"{INDENT}{INDENT}{variable_name} = {refer_to(ctx=ctx, stype=variable_type)}("
+    )
+    if variable_type.properties is not None and len(variable_type.properties) > 0:
         ctx.out.write("\n")
-        for prop in arguments_type.properties.values():
+        for prop in variable_type.properties.values():
             ctx.out.write(f"{INDENT}{INDENT}{INDENT}{prop.name}={prop.name},")
             ctx.out.write("\n")
         ctx.out.write(f"{INDENT}{INDENT})")
     else:
         ctx.out.write(")")
 
+
+def _emit_async_batch_invocation_function(
+    ctx: Context, namespace: builder.SpecNamespace
+) -> None:
+    endpoint = namespace.endpoint
+    if endpoint is None:
+        return
+    if (
+        endpoint.async_batch_path is None
+        or endpoint.is_sdk != EndpointEmitType.EMIT_ENDPOINT
+    ):
+        return
+
+    ctx.out.write("\n")
+    arguments_type = namespace.types["Arguments"]
+    arguments_type = _validate_supports_handler_generation(arguments_type, "arguments")
+    data_type = QUEUED_BATCH_REQUEST_STYPE
+
+    list_str_params: list[builder.SpecType] = []
+    list_str_params.append(
+        builder.SpecTypeGenericParameter(
+            name="str",
+            spec_type_definition=builder.SpecTypeDefnObject(
+                namespace=namespace, name=builder.BaseTypeName.s_string, is_base=True
+            ),
+        )
+    )
+
+    _emit_endpoint_invocation_function_signature(
+        ctx=ctx,
+        endpoint=endpoint,
+        arguments_type=arguments_type,
+        data_type=data_type,
+        extra_params=[
+            builder.SpecProperty(
+                name="depends_on",
+                extant=builder.PropertyExtant.optional,
+                convert_value=builder.PropertyConvertValue.auto,
+                name_case=builder.NameCase.convert,
+                label="depends_on",
+                desc="A list of batch reference keys to process before processing this request",
+                spec_type=builder.SpecTypeInstance(
+                    defn_type=builder.SpecTypeDefnObject(
+                        name=builder.BaseTypeName.s_list,
+                        is_base=True,
+                        namespace=namespace,
+                    ),
+                    parameters=list_str_params,
+                ),
+            )
+        ],
+    )
+
+    # Emit function body
+    _emit_instantiate_type_from_locals(
+        ctx=ctx, variable_name="args", variable_type=arguments_type
+    )
+
+    path = _emit_value(
+        ctx=ctx,
+        stype=ASYNC_BATCH_REQUEST_PATH_STYPE,
+        value=endpoint.async_batch_path,
+    )
+
+    ctx.out.write(
+        f"""
+        json_data = serialize_for_api(args)
+
+        batch_reference = str(uuid.uuid4())
+
+        req = {refer_to(ctx=ctx, stype=ASYNC_BATCH_REQUEST_STYPE)}(
+            path={path},
+            data=json_data,
+            depends_on=depends_on,
+            batch_reference=batch_reference,
+        )
+
+        self._enqueue(req)
+
+        return {refer_to(ctx=ctx, stype=data_type)}(
+            path=req.path,
+            batch_reference=req.batch_reference,
+        )"""
+    )
+
+
+def _emit_endpoint_invocation_function(
+    ctx: Context, namespace: builder.SpecNamespace
+) -> None:
+    endpoint = namespace.endpoint
+    if endpoint is None:
+        return
+    if endpoint.is_sdk != EndpointEmitType.EMIT_ENDPOINT or endpoint.is_beta:
+        return
+
+    ctx.out.write("\n")
+    arguments_type = namespace.types["Arguments"]
+    data_type = namespace.types["Data"]
+    arguments_type = _validate_supports_handler_generation(arguments_type, "arguments")
+    data_type = _validate_supports_handler_generation(
+        data_type, "response", supports_inheritance=True
+    )
+
+    _emit_endpoint_invocation_function_signature(
+        ctx=ctx, endpoint=endpoint, arguments_type=arguments_type, data_type=data_type
+    )
+
+    endpoint_method_stype = builder.SpecTypeDefnObject(
+        namespace=arguments_type.namespace, name=ENDPOINT_METHOD
+    )
+    endpoint_path_stype = builder.SpecTypeDefnObject(
+        namespace=arguments_type.namespace, name=ENDPOINT_PATH
+    )
+
+    # Emit function body
+    _emit_instantiate_type_from_locals(
+        ctx=ctx, variable_name="args", variable_type=arguments_type
+    )
+
     ctx.out.write(
         f"""
         api_request = APIRequest(
@@ -415,7 +625,6 @@ def _emit_endpoint_invocation_function(
         )
         return self.do_request(api_request=api_request, return_type={refer_to(ctx=ctx, stype=data_type)})"""
     )
-    ctx.out.write("\n")
 
 
 def _emit_string_enum(ctx: Context, stype: builder.SpecTypeDefnStringEnum) -> None:
@@ -433,7 +642,9 @@ def _emit_string_enum(ctx: Context, stype: builder.SpecTypeDefnStringEnum) -> No
             ctx.out.write(f"{INDENT}labels={{\n")
             for entry in stype.values.values():
                 if entry.label is not None:
-                    ctx.out.write(f'{INDENT}{INDENT}"{entry.value}": "{entry.label}",\n')
+                    ctx.out.write(
+                        f'{INDENT}{INDENT}"{entry.value}": "{entry.label}",\n'
+                    )
 
             ctx.out.write(f"{INDENT}}},\n")
         if need_deprecated:
@@ -464,12 +675,12 @@ def _emit_string_enum(ctx: Context, stype: builder.SpecTypeDefnStringEnum) -> No
         )
 
 
-@dataclass
+@dataclasses.dataclass
 class EmittedPropertiesMetadata:
-    unconverted_keys: Set[str]
-    unconverted_values: Set[str]
-    to_string_values: Set[str]
-    parse_require: Set[str]
+    unconverted_keys: set[str]
+    unconverted_values: set[str]
+    to_string_values: set[str]
+    parse_require: set[str]
 
 
 def _emit_type_properties(
@@ -480,16 +691,31 @@ def _emit_type_properties(
     num_indent: int = 1,
     separator: str = "\n",
 ) -> EmittedPropertiesMetadata:
-    unconverted_keys: Set[str] = set()
-    unconverted_values: Set[str] = set()
-    to_string_values: Set[str] = set()
-    parse_require: Set[str] = set()
+    return _emit_properties(
+        ctx=ctx,
+        class_out=class_out,
+        properties=list((stype.properties or {}).values()),
+        num_indent=num_indent,
+        separator=separator,
+    )
+
+
+def _emit_properties(
+    *,
+    ctx: Context,
+    class_out: io.StringIO,
+    properties: list[builder.SpecProperty],
+    num_indent: int = 1,
+    separator: str = "\n",
+) -> EmittedPropertiesMetadata:
+    unconverted_keys: set[str] = set()
+    unconverted_values: set[str] = set()
+    to_string_values: set[str] = set()
+    parse_require: set[str] = set()
 
-    if stype.properties is not None and len(stype.properties) > 0:
+    if len(properties) > 0:
 
         def write_field(prop: builder.SpecProperty) -> None:
-            # Checked in outer function, MyPy doens't track the check inside here
-            assert isinstance(stype, builder.SpecTypeDefn)
             if prop.name_case == builder.NameCase.preserve:
                 unconverted_keys.add(prop.name)
             py_name = python_field_name(prop.name, prop.name_case)
@@ -512,20 +738,30 @@ def _emit_type_properties(
                 default = "MISSING_SENTRY"
                 ctx.use_missing = True
             elif prop.extant == builder.PropertyExtant.optional:
-                ref_type = f"typing.Optional[{ref_type}]"
+                if ref_type != "None":
+                    ref_type = f"{ref_type} | None"
                 default = "None"
             elif prop.has_default:
                 default = _emit_value(ctx, prop.spec_type, prop.default)
-
+                if (
+                    isinstance(prop.spec_type, builder.SpecTypeInstance)
+                    and (
+                        prop.spec_type.defn_type.is_base_type(
+                            builder.BaseTypeName.s_list
+                        )
+                    )
+                    and default == "[]"
+                ):
+                    default = "dataclasses.field(default_factory=list)"
             class_out.write(f"{INDENT * num_indent}{py_name}: {ref_type}")
             if default:
                 class_out.write(f" = {default}")
             class_out.write(separator)
 
-        for prop in stype.properties.values():
+        for prop in properties:
             if prop.extant == builder.PropertyExtant.required:
                 write_field(prop)
-        for prop in stype.properties.values():
+        for prop in properties:
             if prop.extant != builder.PropertyExtant.required:
                 write_field(prop)
     else:
@@ -539,6 +775,12 @@ def _emit_type_properties(
     )
 
 
+def _named_type_path(ctx: Context, stype: builder.SpecTypeDefn) -> str:
+    parts = [] if stype.is_base else stype.namespace.path.copy()
+    parts.append(stype.name)
+    return f"{ctx.builder.top_namespace}.{'.'.join(parts)}"
+
+
 def _emit_type(ctx: Context, stype: builder.SpecType) -> None:
     if not isinstance(stype, builder.SpecTypeDefn):
         return
@@ -559,7 +801,42 @@ 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):
+        ctx.use_serial_union = True
+        ctx.out.write(f"{stype.name} = typing.Annotated[\n")
+        ctx.out.write(f"{INDENT}{refer_to(ctx, stype.get_backing_type())},\n")
+        ctx.out.write(f"{INDENT}serial_union_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")
+        if stype.discriminator is not None:
+            ctx.out.write(
+                f"{INDENT * 2}discriminator={util.encode_common_string(stype.discriminator)},\n"
+            )
+        if stype.discriminator_map is not None:
+            ctx.out.write(f"{INDENT * 2}discriminator_map={{\n")
+            for key, value in stype.discriminator_map.items():
+                ctx.out.write(
+                    f"{INDENT * 3}{util.encode_common_string(key)}: {refer_to(ctx, value)},\n"
+                )
+            ctx.out.write(f"{INDENT * 2}}},\n")
+        ctx.out.write(f"{INDENT}),\n")
+        ctx.out.write("]\n")
         return
 
     if isinstance(stype, builder.SpecTypeDefnStringEnum):
@@ -571,11 +848,11 @@ def _emit_type(ctx: Context, stype: builder.SpecType) -> None:
 
     class_out = io.StringIO()
     base_class = ""
-    generic = stype.get_generic()
+    generics = stype.get_generics()
     if not stype.base.is_base:
         base_class = f"({refer_to(ctx, stype.base)})"
-    elif generic is not None:
-        base_class = f"(typing.Generic[{generic}])"
+    elif len(generics) > 0:
+        base_class = f"(typing.Generic[{', '.join(generics)}])"
     class_out.write(f"class {stype.name}{base_class}:\n")
 
     emitted_properties_metadata = _emit_type_properties(
@@ -586,45 +863,45 @@ def _emit_type(ctx: Context, stype: builder.SpecType) -> None:
     to_string_values = emitted_properties_metadata.to_string_values
     parse_require = emitted_properties_metadata.parse_require
 
-    _emit_generic(ctx, stype.get_generic())
+    _emit_generics(ctx, generics)
 
-    if (
-        len(unconverted_values) > 0
-        or len(to_string_values) > 0
-        or len(unconverted_keys) > 0
-        or len(parse_require) > 0
-    ):
-        ctx.use_serial_class = True
-        ctx.out.write("@serial_class(\n")
+    # Emit serial_class decorator
+    ctx.out.write("@serial_class(\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")
 
-        def write_values(key: str, values: set[str]) -> None:
-            if len(values) == 0:
-                return
-            value_str = ", ".join([f'"{name}"' for name in sorted(values)])
-            ctx.out.write(f"{INDENT}{key}={{{value_str}}},\n")
+    def write_values(key: str, values: set[str]) -> None:
+        if len(values) == 0:
+            return
+        value_str = ", ".join([f'"{name}"' for name in sorted(values)])
+        ctx.out.write(f"{INDENT}{key}={{{value_str}}},\n")
 
-        write_values("unconverted_keys", unconverted_keys)
-        write_values("unconverted_values", unconverted_values)
-        write_values("to_string_values", to_string_values)
-        write_values("parse_require", parse_require)
+    write_values("unconverted_keys", unconverted_keys)
+    write_values("unconverted_values", unconverted_values)
+    write_values("to_string_values", to_string_values)
+    write_values("parse_require", parse_require)
 
-        ctx.out.write(")\n")
+    ctx.out.write(")\n")
 
-    dataclass = "@dataclass"
+    # Emit dataclass decorator
+    dataclass = "@dataclasses.dataclass"
     dc_args = []
     if stype.is_kw_only():
         dc_args.append("kw_only=True")
     if stype.is_hashable:
         dc_args.extend(["frozen=True", "eq=True"])
     if len(dc_args) > 0:
-        dataclass += f'({", ".join(dc_args)})'
+        dataclass += f"({', '.join(dc_args)})"
 
     ctx.out.write(f"{dataclass}\n")
     ctx.out.write(class_out.getvalue())
 
 
-def _emit_generic(ctx: Context, generic: Optional[str]) -> None:
-    if generic is not None:
+def _emit_generics(ctx: Context, generics: list[str]) -> None:
+    for generic in generics:
         ctx.out.write(f'{generic} = typing.TypeVar("{generic}")\n')
         ctx.out.write(f"{LINE_BREAK}{LINE_BREAK}")
 
@@ -654,6 +931,7 @@ base_name_map = {
     builder.BaseTypeName.s_opaque_key: "OpaqueKey",
     builder.BaseTypeName.s_string: "str",
     builder.BaseTypeName.s_tuple: "tuple",
+    builder.BaseTypeName.s_readonly_array: "tuple",
     builder.BaseTypeName.s_union: "typing.Union",
     builder.BaseTypeName.s_literal: "typing.Literal",
 }
@@ -662,6 +940,11 @@ 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])
+
+        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}, ..."
+
         return f"{refer_to(ctx, stype.defn_type)}[{params}]"
 
     if isinstance(stype, builder.SpecTypeLiteralWrapper):
@@ -688,23 +971,21 @@ def refer_to(ctx: TrackingContext, stype: builder.SpecType) -> str:
 SpecEndpoint = builder.SpecEndpoint
 
 
-def _route_identifier(endpoint: builder.SpecEndpoint) -> tuple[str, str, str]:
-    return (endpoint.path_dirname, endpoint.path_basename, endpoint.method)
-
-
 def _emit_routes(*, builder: builder.SpecBuilder, config: PythonConfig) -> None:
     for endpoint_root in builder.api_endpoints:
         endpoints: list[SpecEndpoint] = []
         output = config.routes_output.get(endpoint_root)
         if output is None:
             continue
+        last_endpoint: SpecEndpoint | None = None
         for namespace in builder.namespaces.values():
             endpoint = namespace.endpoint
+            last_endpoint = endpoint
             if endpoint is None:
                 continue
-            if endpoint.root != endpoint_root:
+            if endpoint_root not in endpoint.path_per_api_endpoint:
                 continue
-            if endpoint.function is None:
+            if endpoint.path_per_api_endpoint[endpoint_root].function is None:
                 continue
 
             endpoints.append(endpoint)
@@ -717,25 +998,38 @@ def _emit_routes(*, builder: builder.SpecBuilder, config: PythonConfig) -> None:
 from main.site.framework.types import StaticRouteType
 """
         )
+
+        def _route_identifier(endpoint: SpecEndpoint) -> tuple[str, str, str]:
+            endpoint_specific_path = endpoint.path_per_api_endpoint[endpoint_root]
+            return (
+                endpoint_specific_path.path_dirname,
+                endpoint_specific_path.path_basename,
+                endpoint.method,
+            )
+
         sorted_endpoints = sorted(endpoints, key=_route_identifier)
 
-        assert len(endpoints) == len(
-            set(map(_route_identifier, endpoints))
-        ), "Endpoints are not unique"
+        assert len(endpoints) == len(set(map(_route_identifier, endpoints))), (
+            "Endpoints are not unique"
+        )
 
         path_set = set()
         for endpoint in sorted_endpoints:
-            assert endpoint.function
-            func_bits = endpoint.function.split(".")
+            last_endpoint = endpoint
+            endpoint_function_path = endpoint.path_per_api_endpoint[endpoint_root]
+            assert endpoint_function_path.function
+            func_bits = endpoint_function_path.function.split(".")
             path = ".".join(func_bits[:-1])
             if path in path_set:
                 continue
             path_set.add(path)
             static_out.write(f"import {path}\n")
 
+        assert last_endpoint is not None
+
         static_out.write(
             f"""
-ROUTE_PREFIX = "/{endpoint.path_root}"
+ROUTE_PREFIX = "/{last_endpoint.path_per_api_endpoint[endpoint_root].path_root}"
 
 ROUTES: list[StaticRouteType] = [
 """
@@ -749,20 +1043,21 @@ ROUTES: list[StaticRouteType] = [
 
 from main.site.framework.types import DynamicRouteType
 
-ROUTE_PREFIX = "/{endpoint.path_root}"
+ROUTE_PREFIX = "/{last_endpoint.path_per_api_endpoint[endpoint_root].path_root}"
 
 ROUTES: list[DynamicRouteType] = [
 """
         )
 
         for endpoint in sorted_endpoints:
+            endpoint_function_path = endpoint.path_per_api_endpoint[endpoint_root]
             dynamic_out.write(
-                f'{INDENT}("{endpoint.path_dirname}/{endpoint.path_basename}", "{endpoint.function}", ["{endpoint.method.upper()}"]),\n'
+                f'{INDENT}("{endpoint_function_path.path_dirname}/{endpoint_function_path.path_basename}", "{endpoint_function_path.function}", ["{endpoint.method.upper()}"]),\n'
             )
 
-            assert endpoint.function
+            assert endpoint_function_path.function
             static_out.write(
-                f'{INDENT}("{endpoint.path_dirname}/{endpoint.path_basename}", {endpoint.function}, ["{endpoint.method.upper()}"]),\n'
+                f'{INDENT}("{endpoint_function_path.path_dirname}/{endpoint_function_path.path_basename}", {endpoint_function_path.function}, ["{endpoint.method.upper()}"]),\n'
             )
 
         dynamic_out.write(f"{MODIFY_NOTICE}]\n")
@@ -777,16 +1072,22 @@ ROUTES: list[DynamicRouteType] = [
 def _emit_namespace_imports(
     *,
     out: io.StringIO,
-    namespaces: Set[builder.SpecNamespace],
-    from_namespace: Optional[builder.SpecNamespace],
+    namespaces: set[builder.SpecNamespace],
+    from_namespace: builder.SpecNamespace | None,
     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(
@@ -798,7 +1099,7 @@ def _emit_namespace_imports(
         else:
             from_path = config.types_package
 
-        out.write(f"from {from_path} import {resolved} as {ref}\n")
+        out.write(f"from {from_path} import {resolved}\n")
 
 
 def _emit_id_source(*, builder: builder.SpecBuilder, config: PythonConfig) -> None:
@@ -810,7 +1111,7 @@ 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, Type, Union\n")
+    enum_out.write("from typing import Literal, Union\n")
     enum_out.write("from pkgs.strenum_compat import StrEnum\n")
 
     ctx = TrackingContext()
@@ -825,13 +1126,13 @@ def _emit_id_source(*, builder: builder.SpecBuilder, config: PythonConfig) -> No
     )
 
     known_keys = []
-    enum_out.write("\nENUM_MAP: dict[str, Type[StrEnum]] = {\n")
+    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"}}\n{MODIFY_NOTICE}\n")
 
-    enum_out.write(f"\nKnownEnumsType = Union[\\\n{INDENT}")
+    enum_out.write(f"\nKnownEnumsType = Union[\n{INDENT}")
     enum_out.write(f",\n{INDENT}".join(known_keys))
     enum_out.write(f"\n]\n{MODIFY_NOTICE}\n")
 
@@ -848,21 +1149,36 @@ def _emit_api_stubs(*, builder: builder.SpecBuilder, config: PythonConfig) -> No
 
             if endpoint is None:
                 continue
-            if endpoint.root != endpoint_root:
+            if endpoint_root not in endpoint.path_per_api_endpoint:
                 continue
-            if endpoint.function is None:
+
+            endpoint_function = endpoint.path_per_api_endpoint[endpoint_root].function
+            if endpoint_function is None:
                 continue
 
-            module_dir, file_name, func_name = endpoint.function.rsplit(".", 2)
+            module_dir, file_name, func_name = endpoint_function.rsplit(".", 2)
             module_path = os.path.abspath(module_dir.replace(".", "/"))
             api_stub_file = f"{module_path}/{file_name}.py"
             if os.path.isfile(api_stub_file):
                 continue
-            _create_api_stub(api_stub_file, file_name, endpoint, config)
+            _create_api_stub(
+                api_stub_file=api_stub_file,
+                file_name=file_name,
+                endpoint=endpoint,
+                config=config,
+                endpoint_root=endpoint_root,
+                top_namespace=builder.top_namespace,
+            )
 
 
 def _create_api_stub(
-    api_stub_file: str, file_name: str, endpoint: SpecEndpoint, config: PythonConfig
+    *,
+    api_stub_file: str,
+    file_name: str,
+    endpoint: SpecEndpoint,
+    config: PythonConfig,
+    endpoint_root: str,
+    top_namespace: str,
 ) -> None:
     assert (
         endpoint.method == builder.RouteMethod.post
@@ -870,7 +1186,13 @@ def _create_api_stub(
         or endpoint.method == builder.RouteMethod.delete
         or endpoint.method == builder.RouteMethod.patch
     )
-    api_out = _create_api_function(file_name, endpoint, config)
+    api_out = _create_api_function(
+        file_name=file_name,
+        endpoint=endpoint,
+        config=config,
+        endpoint_root=endpoint_root,
+        top_namespace=top_namespace,
+    )
     util.rewrite_file(api_stub_file, api_out.getvalue())
 
 
@@ -879,15 +1201,22 @@ WRAP_ARGS_END = "\n"
 
 
 def _create_api_function(
-    file_name: str, endpoint: SpecEndpoint, config: PythonConfig
+    *,
+    file_name: str,
+    endpoint: SpecEndpoint,
+    config: PythonConfig,
+    endpoint_root: str,
+    top_namespace: str,
 ) -> io.StringIO:
+    endpoint_specific_path = endpoint.path_per_api_endpoint[endpoint_root]
+    assert endpoint_specific_path is not None
     api_out = io.StringIO()
     python_api_type_root = f"{config.types_package}.api"
-    dot_dirname = endpoint.path_dirname.replace("/", ".")
+    dot_dirname = endpoint_specific_path.path_dirname.replace("/", ".")
     api_import = (
         f"{python_api_type_root}.{dot_dirname}.{file_name}"
         if dot_dirname != ""
-        else f"{python_api_type_root}.{endpoint.path_basename}"
+        else f"{python_api_type_root}.{endpoint_specific_path.path_basename}"
     )
 
     if endpoint.method == builder.RouteMethod.post:
@@ -899,7 +1228,20 @@ def _create_api_function(
     elif endpoint.method == builder.RouteMethod.patch:
         validated_method = "validated_patch"
 
-    ruff_requires_wrap = len(endpoint.path_basename) > 14
+    ruff_requires_wrap = len(endpoint_specific_path.path_basename) > 14
+
+    account_type = (
+        endpoint_specific_path.root
+        if endpoint_specific_path.root not in ["external", "portal"]
+        else "materials"
+    )
+
+    endpoint_path_name = (
+        ENDPOINT_PATH_ALTERNATE
+        if len(endpoint.path_per_api_endpoint.keys()) > 1
+        and endpoint_specific_path.root != top_namespace
+        else ENDPOINT_PATH
+    )
 
     api_out.write(
         f"""import {api_import} as api
@@ -907,8 +1249,8 @@ from main.db.session import Session, SessionMaker
 from main.site.decorators import APIError, APIResponse, {validated_method}
 
 
-@{validated_method}(api.ENDPOINT_PATH, "{endpoint.root}", api.Arguments)
-def {endpoint.path_basename}({WRAP_ARGS_START if ruff_requires_wrap else ""}args: api.Arguments, client_sm: SessionMaker{WRAP_ARGS_END if ruff_requires_wrap else ""}) -> APIResponse[api.Data]:
+@{validated_method}(api.{endpoint_path_name}, "{account_type}", api.Arguments)
+def {endpoint_specific_path.path_basename}({WRAP_ARGS_START if ruff_requires_wrap else ""}args: api.Arguments, client_sm: SessionMaker{WRAP_ARGS_END if ruff_requires_wrap else ""}) -> APIResponse[api.Data]:
     with Session(client_sm) as session:
         # return APIResponse(data=api.Data())
         pass
@@ -930,7 +1272,7 @@ def _emit_api_argument_lookup(
     for endpoint_root in builder.api_endpoints:
         routes_output = config.routes_output[endpoint_root]
 
-        imports = []
+        imports = ["import typing", "import dataclasses"]
         mappings = []
         for namespace in sorted(
             builder.namespaces.values(),
@@ -940,17 +1282,38 @@ def _emit_api_argument_lookup(
 
             if endpoint is None:
                 continue
-            if endpoint.root != endpoint_root:
+            if endpoint_root not in endpoint.path_per_api_endpoint:
                 continue
-            if endpoint.function is None:
+            if endpoint.path_per_api_endpoint[endpoint_root].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:])
             api_import = f"{config.types_package}.{'.'.join(namespace.path)}"
             imports.append(f"import {api_import} as {import_alias}")
-            mappings.append(f"{import_alias}.ENDPOINT_PATH: {import_alias}.Arguments")
+
+            route_group = (
+                f'"{endpoint.route_group}"'
+                if endpoint.route_group is not None
+                else "None"
+            )
+            account_type = (
+                f'"{endpoint.account_type}"'
+                if endpoint.account_type is not None
+                else "None"
+            )
+
+            mapping = f"{INDENT}ApiEndpointKey(route={import_alias}.ENDPOINT_PATH, method={import_alias}.ENDPOINT_METHOD): ApiEndpointSpec(\n"
+            mapping += f"{INDENT}{INDENT}arguments_type={import_alias}.Arguments,\n"
+            mapping += f"{INDENT}{INDENT}data_type={import_alias}.Data,\n"
+            mapping += f"{INDENT}{INDENT}route_group={route_group},\n"
+            mapping += f"{INDENT}{INDENT}account_type={account_type},\n"
+            mapping += f"{INDENT}{INDENT}route={import_alias}.ENDPOINT_PATH,\n"
+            mapping += f'{INDENT}{INDENT}handler="{endpoint.path_per_api_endpoint[endpoint_root].function}",\n'
+            mapping += f"{INDENT}{INDENT}method={import_alias}.ENDPOINT_METHOD,\n"
+            mapping += f"{INDENT})"
+            mappings.append(mapping)
 
         argument_lookup_out = io.StringIO()
         argument_lookup_out.write(MODIFY_NOTICE)
@@ -958,8 +1321,29 @@ def _emit_api_argument_lookup(
         argument_lookup_out.write(
             f"""{LINE_BREAK.join(imports)}
 
-{API_ARGUMENTS_NAME} = {{
-    {f",{LINE_BREAK}{INDENT}".join(mappings)},
+AT = typing.TypeVar("AT")
+DT = typing.TypeVar("DT")
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class ApiEndpointKey:
+    method: str
+    route: str
+
+
+@dataclasses.dataclass(kw_only=True)
+class ApiEndpointSpec(typing.Generic[AT, DT]):
+    route: str
+    arguments_type: type[AT]
+    data_type: type[DT]
+    route_group: str | None
+    account_type: str | None
+    handler: str
+    method: str
+
+
+{API_ARGUMENTS_NAME}: dict[ApiEndpointKey, ApiEndpointSpec] = {{
+{f",{LINE_BREAK}".join(mappings)},
 }}
 
 __all__ = ["{API_ARGUMENTS_NAME}"]
@@ -975,10 +1359,69 @@ __all__ = ["{API_ARGUMENTS_NAME}"]
 CLIENT_CLASS_FILENAME = "client_base"
 CLIENT_CLASS_IMPORTS = [
     "from abc import ABC, abstractmethod",
-    "from dataclasses import dataclass",
+    "import dataclasses",
+]
+ASYNC_BATCH_PROCESSOR_FILENAME = "async_batch_processor"
+ASYNC_BATCH_PROCESSOR_IMPORTS = [
+    "import uuid",
+    "from abc import ABC, abstractmethod",
+    "from pkgs.serialization_util import serialize_for_api",
 ]
 
 
+def _emit_async_batch_processor(
+    *, spec_builder: builder.SpecBuilder, config: PythonConfig
+) -> None:
+    if not config.emit_async_batch_processor:
+        return
+
+    async_batch_processor_out = io.StringIO()
+    ctx = Context(
+        out=io.StringIO(),
+        namespace=builder.SpecNamespace("async_batch_processor"),
+        builder=spec_builder,
+    )
+
+    for namespace in sorted(
+        spec_builder.namespaces.values(),
+        key=lambda ns: _resolve_namespace_name(ns),
+    ):
+        _emit_async_batch_invocation_function(ctx=ctx, namespace=namespace)
+
+    async_batch_processor_out.write(MODIFY_NOTICE)
+    async_batch_processor_out.write(LINT_HEADER)
+    async_batch_processor_out.write("# ruff: noqa: PLR0904\n")
+
+    _emit_types_imports(out=async_batch_processor_out, ctx=ctx)
+    _emit_namespace_imports(
+        out=async_batch_processor_out,
+        namespaces=ctx.namespaces,
+        from_namespace=None,
+        config=config,
+    )
+
+    async_batch_processor_out.write(
+        f"""{LINE_BREAK.join(ASYNC_BATCH_PROCESSOR_IMPORTS)}
+
+
+class AsyncBatchProcessorBase(ABC):
+    @abstractmethod
+    def _enqueue(self, req: {refer_to(ctx=ctx, stype=ASYNC_BATCH_REQUEST_STYPE)}) -> None:
+        ...
+
+    @abstractmethod
+    def send(self) -> base_t.ObjectId:
+        ..."""
+    )
+    async_batch_processor_out.write(ctx.out.getvalue())
+    async_batch_processor_out.write("\n")
+
+    util.rewrite_file(
+        f"{config.types_output}/{ASYNC_BATCH_PROCESSOR_FILENAME}.py",
+        async_batch_processor_out.getvalue(),
+    )
+
+
 def _emit_client_class(
     *, spec_builder: builder.SpecBuilder, config: PythonConfig
 ) -> None:
@@ -986,7 +1429,11 @@ def _emit_client_class(
         return
 
     client_base_out = io.StringIO()
-    ctx = Context(out=io.StringIO(), namespace=builder.SpecNamespace("client_class"))
+    ctx = Context(
+        out=io.StringIO(),
+        builder=spec_builder,
+        namespace=builder.SpecNamespace("client_base"),
+    )
     for namespace in sorted(
         spec_builder.namespaces.values(),
         key=lambda ns: _resolve_namespace_name(ns),
@@ -1001,8 +1448,9 @@ def _emit_client_class(
     _emit_namespace_imports(
         out=client_base_out,
         namespaces=ctx.namespaces,
-        from_namespace=builder.SpecNamespace("client_base"),
+        from_namespace=None,
         config=config,
+        skip_non_sdk=True,
     )
 
     client_base_out.write(
@@ -1011,7 +1459,7 @@ def _emit_client_class(
 DT = typing.TypeVar("DT")
 
 
-@dataclass(kw_only=True)
+@dataclasses.dataclass(kw_only=True)
 class APIRequest:
     method: str
     endpoint: str
@@ -1022,10 +1470,10 @@ class ClientMethods(ABC):
 
     @abstractmethod
     def do_request(self, *, api_request: APIRequest, return_type: type[DT]) -> DT:
-        ...
-"""
+        ..."""
     )
     client_base_out.write(ctx.out.getvalue())
+    client_base_out.write("\n")
 
     util.rewrite_file(
         f"{config.types_output}/{CLIENT_CLASS_FILENAME}.py", client_base_out.getvalue()