@aws/nx-plugin 1.0.0 → 1.0.2

package/src/open-api/py-client/files/client/__clientModuleName__.py.template

@@ -0,0 +1,1076 @@
+<%_
+/**
+ * The declared type of a single success response, `None` for an empty body.
+ */
+const successType = (resp) => {
+  const py = resp.type === 'void' ? 'None' : resp.pythonClientType || 'None';
+  // A nullable response body may arrive as JSON null.
+  return resp.isNullable && py !== 'None' ? `${py} | None` : py;
+};
+
+/**
+ * The union of every type the operation can return.
+ *
+ * An operation declaring both `200` and `2XX` returns either body, so the
+ * signature admits both rather than only the first.
+ */
+const resultType = (op) => {
+  const types = [...new Set((op.successResponses || []).map(successType))];
+  if (types.length === 0) return 'None';
+  if (types.length === 1) return types[0];
+  return types.join(' | ');
+};
+
+/**
+ * The keywords, httpx methods and typing names that differ between the sync and
+ * async flavours. Everything else below is spelled once.
+ */
+const kw = isAsync
+  ? { def: 'async def', for: 'async for', with: 'async with', await: 'await ' }
+  : { def: 'def', for: 'for', with: 'with', await: '' };
+const hx = isAsync
+  ? { close: 'aclose', read: 'aread', iterText: 'aiter_text', iterLines: 'aiter_lines' }
+  : { close: 'close', read: 'read', iterText: 'iter_text', iterLines: 'iter_lines' };
+const enterName = isAsync ? '__aenter__' : '__enter__';
+const exitName = isAsync ? '__aexit__' : '__exit__';
+const contextManager = isAsync ? 'asynccontextmanager' : 'contextmanager';
+const asyncPrefix = isAsync ? 'Async' : '';
+const clientClassName = `${asyncPrefix}${className}`;
+
+/**
+ * The declared type of a streamed operation. Async uses `AsyncGenerator` rather
+ * than `AsyncIterator` so a caller who stops early can `aclose()` the stream in
+ * a type-safe way; its send type defaults to `None`, so it is left off (ruff
+ * `UP043`).
+ */
+const streamType = (item) => `${isAsync ? 'AsyncGenerator' : 'Iterator'}[${item}]`;
+
+/**
+ * The `collections.abc` names the module imports. Async needs two — a
+ * `AsyncGenerator` for an operation's stream and a separate `AsyncIterator` for
+ * the `_stream_with_url` yield type — where sync spells both `Iterator`.
+ */
+const streamAbc = isAsync ? 'AsyncGenerator' : 'Iterator';
+const contextAbc = isAsync ? 'AsyncIterator' : 'Iterator';
+
+const resultTypeFor = (op) => {
+  if (op.isStreaming) {
+    // A void response has no item type, so the raw text lines are yielded.
+    if (!op.result || op.result.type === 'void') return streamType('str');
+    const jsonl = (op.responses || []).find(r => r.isJsonlStreaming);
+    if (jsonl && jsonl.itemSchemaModel) return streamType(jsonl.itemSchemaModel.pythonClientType);
+    return streamType(op.result.pythonClientType);
+  }
+  return resultType(op);
+};
+
+/**
+ * Whether the response's type resolves to a module-level alias (a collection,
+ * union or literal) rather than a pydantic class, which decides between
+ * `TypeAdapter(X)` and `X.model_validate(...)`.
+ */
+const isPythonAlias = (resp) =>
+  !!resp.referencedCollectionKind ||
+  ['one-of', 'any-of', 'enum', 'tuple'].includes(resp.export) ||
+  !!resp.isEnum;
+
+/**
+ * The structured Python type of a model, so these templates can ask what a type
+ * is rather than matching on how it is spelled.
+ */
+const pythonTypeOf = (model) => model.pythonTypeTree ?? { kind: 'builtin', name: 'Any' };
+
+/**
+ * Whether the model's Python type is a single value rather than a container or a
+ * generated class — a `str`, an `int`, or a `Literal` from an enum. Such a body
+ * has a text form of its own, so a non-JSON media type sends it verbatim.
+ */
+const isPythonScalarType = (model) => {
+  const type = pythonTypeOf(model);
+  return type.kind === 'literal' || type.kind === 'builtin';
+};
+
+/**
+ * Whether the value is validated by calling `model_validate` on a generated
+ * pydantic class. Anything else — a primitive, collection, literal or a name
+ * bound to a module-level alias — goes through a `TypeAdapter`.
+ */
+const isModelClass = (model) =>
+  !needsPythonTypeAdapter(pythonTypeOf(model)) && !isPythonAlias(model);
+
+/** Whether a media type carries a JSON payload. */
+const isJsonMediaType = (mediaType) => {
+  const base = (mediaType || '').split(';')[0].trim();
+  return base === 'application/json' || base.endsWith('+json');
+};
+
+/** Whether a response arrives as JSON on the wire. */
+const isJsonWire = (resp) =>
+  (resp.mediaTypes || []).some(isJsonMediaType);
+
+/**
+ * Render the expression that turns an httpx response into the operation's
+ * declared type.
+ *
+ * A primitive on a JSON wire arrives JSON-encoded (a string body is `"hello"`,
+ * quotes included), so it is parsed rather than read as text; on a non-JSON
+ * wire it is coerced from the raw text instead. Anything with structure —
+ * a collection, tuple, union or literal alias — is validated whole, since
+ * `resp.type` names the *element* type for an inline collection and can't be
+ * dispatched on directly.
+ */
+const responseParseExpr = (resp) => {
+  if (resp.type === 'void') return 'None';
+  if (resp.type === 'binary') return 'response.content';
+  const py = resp.pythonClientType || 'Any';
+  const isJsonMedia = isJsonWire(resp);
+  // A response declaring JSON alongside another media type can arrive as either,
+  // and a declared-JSON body can arrive empty, so the body is read through a
+  // helper that tolerates both rather than assuming `response.json()` succeeds.
+  const jsonBody =
+    (resp.mediaTypes || []).length > 1 ? 'self._json_body(response)' : 'response.json()';
+  // An enum or union alias is a single value on the wire, so it reads like a
+  // scalar even though it renders as a module-level alias. A referenced
+  // collection alias resolves to a container, so it is validated as one.
+  const isCollection =
+    isPythonCollection(pythonTypeOf(resp)) ||
+    ['array', 'dictionary'].includes(resp.referencedCollectionKind);
+  const isScalar = !isCollection;
+  const nullable = resp.isNullable ? (t) => `${t} | None` : (t) => t;
+  if (isScalar) {
+    if (py === 'Any') return isJsonMedia ? jsonBody : 'response.text';
+    // A non-JSON wire hands over text, which pydantic coerces to the declared
+    // type (`"7"` to 7, `"true"` to True, an ISO string to a date).
+    if (!isJsonMedia) {
+      return `TypeAdapter(${nullable(py)}).validate_strings(response.text.strip())`;
+    }
+    // `str` and `Any` need no coercion from a JSON body; every other declared
+    // type does (a JSON number to `float`, an ISO string to a `date`).
+    if ((py === 'str' || py === 'Any') && !resp.isNullable) {
+      return jsonBody;
+    }
+    if (isModelClass(resp) && !resp.isNullable) {
+      return `${py}.model_validate(${jsonBody})`;
+    }
+    return `TypeAdapter(${nullable(py)}).validate_python(${jsonBody})`;
+  }
+  if (!isJsonMedia && py === 'Any') return 'response.text';
+  return `TypeAdapter(${nullable(py)}).validate_python(${jsonBody})`;
+};
+
+/**
+ * Parse one streamed JSON Lines item. A model class validates itself; anything
+ * else (a primitive, collection or alias) goes through a `TypeAdapter`.
+ */
+const streamItemParseExpr = (itemModel, lineVar) => {
+  const py = itemModel.pythonClientType || 'Any';
+  if (py === 'Any') return `json.loads(${lineVar})`;
+  if (!isModelClass(itemModel)) {
+    return `TypeAdapter(${py}).validate_json(${lineVar})`;
+  }
+  return `${py}.model_validate_json(${lineVar})`;
+};
+
+/**
+ * Parse one chunk of a non-JSONL (`x-streaming`) response. A chunk is a
+ * fragment of the stream rather than a whole document, so a text response
+ * passes through; anything else is deserialised to the declared type, matching
+ * the return annotation the caller sees.
+ */
+const streamChunkParseExpr = (resp, lineVar) => {
+  const py = resp.type === 'void' ? 'None' : resp.pythonClientType || 'Any';
+  // A void response has no item type, so the line is yielded as text rather
+  // than validated against `None`, which nothing satisfies.
+  if (py === 'None' || py === 'str' || py === 'Any') return lineVar;
+  if (!isModelClass(resp)) {
+    return `TypeAdapter(${py}).validate_json(${lineVar})`;
+  }
+  return `${py}.model_validate_json(${lineVar})`;
+};
+
+/**
+ * Render text from the spec as a Python docstring body. A description is
+ * arbitrary text, so it goes through the same escaping as any other literal
+ * (backslash first) with the surrounding quotes stripped.
+ */
+/** A wire name as a Python string literal, so a quote in it cannot end the string. */
+const pyStr = (value) => toPythonLiteral(String(value));
+
+const pyDocstring = (text) =>
+  toPythonLiteral(String(text ?? '').replace(/\r?\n/g, ' ')).slice(1, -1);
+
+/**
+ * An operation's docstring, indented and wrapped to the vended line length so
+ * a long description doesn't trip the `E501` the generated project lints with.
+ * Returns the empty string when the operation has nothing to say.
+ */
+const methodDocstring = (op, indent) => {
+  const text = (op.description || op.summary || '').split('\n')[0];
+  if (!text) return '';
+  const body = pyDocstring(text);
+  const oneLine = `${indent}"""${body}"""`;
+  if (oneLine.length <= 120) return `${oneLine}\n`;
+  // Greedily fill lines, leaving room for the indent.
+  const width = 120 - indent.length;
+  const lines = [];
+  let current = '';
+  for (const word of body.split(' ')) {
+    if (current && `${current} ${word}`.length > width) {
+      lines.push(current);
+      current = word;
+    } else {
+      current = current ? `${current} ${word}` : word;
+    }
+  }
+  if (current) lines.push(current);
+  return `${indent}"""\n${lines.map((l) => `${indent}${l}`).join('\n')}\n${indent}"""\n`;
+};
+
+const responseStatusCondition = (code) => {
+  if (typeof code === 'string' && /^\dXX$/.test(code)) {
+    const base = Number(code.charAt(0)) * 100;
+    return `${base} <= response.status_code < ${base + 100}`;
+  }
+  return `response.status_code == ${code}`;
+};
+
+/** Whether a response is one the operation returns rather than raises for. */
+const isSuccessResponse = (op, resp) =>
+  (op.successResponses || []).some((r) => r.code === resp.code);
+
+/**
+ * Whether one branch always runs, making the trailing raise unreachable.
+ *
+ * Only an error `default` is unconditional: as the success branch it carries a
+ * 2xx check, so a non-2xx status still falls through to the raise below.
+ */
+const hasUnconditionalBranch = (op) =>
+  (op.responses || []).some(
+    (r) => r.code === 'default' && !isSuccessResponse(op, r),
+  );
+
+/**
+ * The status check guarding a response branch, or null when none is needed.
+ *
+ * `default` matches any status the spec did not enumerate, so it needs no check
+ * — except where it is the success branch, which only a 2xx status may take.
+ */
+const branchCondition = (op, resp) => {
+  if (resp.code !== 'default') return responseStatusCondition(resp.code);
+  return isSuccessResponse(op, resp) ? '200 <= response.status_code < 300' : null;
+};
+
+/**
+ * Render the error raise expression for a non-success response.
+ *
+ * The payload is handed over raw and coerced by the wrapper, so a body that
+ * doesn't match the schema the spec declares still surfaces as the typed
+ * exception rather than a validation error over the error itself.
+ */
+const renderTypedRaise = (op, resp) => {
+  const entry = (op.errorShape?.entries || []).find((e) => e.code === resp.code);
+  const cls = op.errorShape.exceptionClassName;
+  if (!entry) return `raise ${cls}(response.status_code, None)`;
+  const payload = resp.type === 'void'
+    ? 'None'
+    : resp.type === 'binary'
+      ? 'response.content'
+      : 'self._error_payload(response)';
+  // For exact numeric codes we can pass the literal value directly so the
+  // Literal-typed `status` field type-checks with no suppression.
+  const statusExpr = entry.isExactCode
+    ? String(entry.code)
+    : 'response.status_code';
+  return (
+    `raise ${cls}(\n` +
+    `                response.status_code,\n` +
+    `                self._error(\n` +
+    `                    types.${entry.className}, ${statusExpr}, ${payload}\n` +
+    `                ),\n` +
+    `            )`
+  );
+};
+
+/** Is this operation a single-body call eligible for positional-arg style? */
+const isPositionalBody = (op) => !!op.requestShape?.isSingleBodyInput;
+
+/** Build the `def method(self, *, …)` signature from the generic request shape. */
+const signature = (op) => {
+  const inputs = op.requestShape?.inputs ?? [];
+  if (inputs.length === 0) return 'self';
+  if (isPositionalBody(op)) {
+    const k = inputs[0];
+    return `self,\n        ${k.pythonName}: ${k.pythonAnnotation}${k.isRequired ? '' : ' = None'}`;
+  }
+  const parts = ['self', '*'];
+  for (const k of inputs) {
+    parts.push(k.isRequired
+      ? `${k.pythonName}: ${k.pythonAnnotation}`
+      : `${k.pythonName}: ${k.pythonAnnotation} = None`);
+  }
+  return parts.join(',\n        ');
+};
+
+const inputsByKind = (op, kind) =>
+  (op.requestShape?.inputs ?? []).filter((k) => k.source.kind === kind);
+
+// Derived from the resolved attribute name, which the shared codegen has
+// already made a valid identifier — the raw tag may be any string at all.
+const pythonClassNameForTag = (tag) => {
+  const name = pythonTagNames[tag];
+  return `_${asyncPrefix}${name.charAt(0).toUpperCase()}${name.slice(1)}Namespace`;
+};
+
+// `operationsByTag` keys are already normalised to identifiers by the shared
+// codegen, and `pythonTagNames` maps each to its snake_case attribute name.
+const tagGroups = operationsByTag;
+// A content-based parameter (declared with `content` rather than `schema`)
+// is serialised to its media type — JSON — as a single value.
+const hasContentJsonParams = allOperations.some(op => (op.parameters || []).some(p => p.in !== 'body' && p.mediaType === 'application/json'));
+const hasPartContentTypes = allOperations.some(op => op.parametersBody && op.parametersBody.partContentTypes);
+const hasAllowReservedParams = allOperations.some(op => (op.parameters || []).some(p => p.in === 'query' && p.allowReserved));
+const abcImports = [...new Set([streamAbc, ...(hasAllowReservedParams ? [contextAbc] : [])])].join(', ');
+// A response declaring several media types is read through `_json_body`.
+const hasMultiMediaResponse = allOperations.some(op => (op.responses || []).some(r => (r.mediaTypes || []).length > 1));
+// An untyped streamed item is decoded with `json.loads`, which needs the import.
+const hasUntypedStreamItems = allOperations.some(op => (op.responses || []).some(r =>
+  r.isJsonlStreaming && r.itemSchemaModel && (r.itemSchemaModel.pythonClientType || 'Any') === 'Any'));
+// A structured multipart part is JSON encoded before it becomes a text part.
+const hasMultipartBody = allOperations.some(op => {
+  const shape = op.requestShape;
+  const body = shape && (shape.bodyFromFields || shape.bodyAsSingleInput);
+  return !!body && body.mediaType === 'multipart/form-data';
+});
+// Render the `self._url(...)` expression for an operation, including matrix/
+// label path styles when declared.
+const urlExpr = (op, pathInputs, styledPathInputs) => {
+  let expr = `self._url("${op.path}", ${pathInputs.length > 0 ? "path_params" : "{}"}`;
+  if (styledPathInputs.length > 0) {
+    expr += `, path_styles={${styledPathInputs.map(k => `"${k.source.wireName}": ("${k.model.pathStyle}", ${k.model.pathExplode ? 'True' : 'False'})`).join(', ')}}`;
+  }
+  return expr + ')';
+};
+_%>
+"""<%- clientClassName %> — AUTO-GENERATED <%- isAsync ? 'asynchronous' : 'synchronous' %> client."""
+
+from __future__ import annotations
+
+import datetime
+<%_ if (hasContentJsonParams || hasPartContentTypes || hasUntypedStreamItems || hasMultipartBody) { _%>
+import json
+<%_ } _%>
+import warnings
+from collections.abc import <%- abcImports %>
+<%_ if (hasAllowReservedParams) { _%>
+from contextlib import <%- contextManager %>
+<%_ } _%>
+from dataclasses import dataclass, field
+from typing import Any, Literal, TypeVar
+from urllib.parse import quote
+
+import httpx
+from pydantic import BaseModel, TypeAdapter, ValidationError
+
+from . import types
+from .errors import (
+    ApiError as ApiError,
+<%_ allOperations.forEach((op) => { _%>
+    <%- op.errorShape.exceptionClassName %> as <%- op.errorShape.exceptionClassName %>,
+<%_ }); _%>
+)
+
+_ErrorT = TypeVar("_ErrorT", bound=BaseModel)
+
+
+@dataclass
+class <%- clientClassName %>Config:
+    """Client configuration for <%- clientClassName %>."""
+
+    #: Base URL for the API.
+    url: str
+    #: Client used for every request. Supply your own to add authentication or
+    #: any other middleware — an ``httpx.Auth`` (e.g. a SigV4 signer), an event
+    #: hook, a custom transport, timeouts, retries or a proxy all apply, and the
+    #: client's own headers and query params are sent alongside each operation's.
+    #: A supplied client is never closed by this one, so it can be shared.
+    httpx_client: httpx.<%- asyncPrefix %>Client | None = None
+    #: Headers added to every request, where the operation sets none itself.
+    headers: dict[str, str] = field(default_factory=dict)
+    #: By default the client sends a Content-Type header set to the media type
+    #: the OpenAPI specification declares for the request. Set this to omit it.
+    omit_content_type_header: bool = False
+
+
+class <%- clientClassName %>:
+    """<%- isAsync ? 'Asynchronous' : 'Synchronous' %> API client for <%- className %>."""
+
+    def __init__(self, config: <%- clientClassName %>Config) -> None:
+        self._config = config
+        self._client = config.httpx_client or httpx.<%- asyncPrefix %>Client()
+        self._owns_client = config.httpx_client is None
+        self._base_url = config.url.rstrip("/")
+<%_ Object.keys(tagGroups).forEach((tag) => { _%>
+        self.<%- pythonTagNames[tag] %>: <%- pythonClassNameForTag(tag) %> = <%- pythonClassNameForTag(tag) %>(self)
+<%_ }); _%>
+
+    <%- kw.def %> <%- enterName %>(self) -> <%- clientClassName %>:
+        return self
+
+    <%- kw.def %> <%- exitName %>(self, *exc: Any) -> None:
+        <%- kw.await %>self.<%- hx.close %>()
+
+    <%- kw.def %> <%- hx.close %>(self) -> None:
+        if self._owns_client:
+            <%- kw.await %>self._client.<%- hx.close %>()
+
+    def _url(
+        self,
+        path: str,
+        path_params: dict[str, Any],
+        path_styles: dict[str, tuple[str, bool]] | None = None,
+    ) -> str:
+        for key, value in path_params.items():
+            style, explode = (path_styles or {}).get(key, ("simple", False))
+            # An object expands to its key,value members; a list to its items.
+            # Each is encoded on its own so the separators between them stay
+            # literal, as RFC 6570 requires.
+            dumped = self._dump(value)
+            if isinstance(dumped, dict):
+                values = [
+                    part
+                    for k, v in dumped.items()
+                    if v is not None
+                    for part in (k, self._scalar(v))
+                ]
+            elif isinstance(dumped, list):
+                values = list(dumped)
+            else:
+                values = [value]
+            if style == "matrix":
+                # RFC 6570 path-style expansion: ;key=a,b (explode: ;key=a;key=b)
+                if explode:
+                    rendered = "".join(";" + key + "=" + quote(self._scalar(v), safe="") for v in values)
+                else:
+                    rendered = ";" + key + "=" + ",".join(quote(self._scalar(v), safe="") for v in values)
+            elif style == "label":
+                # RFC 6570 label expansion: .a,b (explode: .a.b)
+                rendered = "." + ("." if explode else ",").join(quote(self._scalar(v), safe="") for v in values)
+            else:
+                # RFC 6570 simple expansion: a list renders comma-separated.
+                rendered = ",".join(quote(self._scalar(v), safe="") for v in values)
+            path = path.replace("{" + key + "}", rendered)
+        return self._base_url + path
+
+<%_ if (hasAllowReservedParams) { _%>
+    def _query_string(
+        self,
+        query_params: dict[str, Any],
+        collection_formats: dict[str, str] | None,
+        reserved: set[str],
+    ) -> str:
+        # Build the query string manually: httpx percent-encodes reserved
+        # characters, which allowReserved parameters must keep literal. The
+        # httpx client's own params are folded in here, because a client with
+        # params set would otherwise replace this query string wholesale.
+        parts: list[str] = [
+            quote(str(key), safe="") + "=" + quote(str(value), safe="")
+            for key, value in self._client.params.multi_items()
+        ]
+        for key, value in self._query(query_params, collection_formats).items():
+            # RFC 3986 reserved characters kept literal for an allowReserved
+            # parameter. `#` is excluded: it would start the URL fragment and
+            # silently drop this value and every parameter after it.
+            safe = "/:?[]@!$&'()*+,;=" if key in reserved else ""
+            values = value if isinstance(value, list) else [value]
+            for v in values:
+                parts.append(quote(str(key), safe="") + "=" + quote(self._scalar(v), safe=safe))
+        return "&".join(parts)
+
+<%_ } _%>
+    def _deep_object(self, key: str, value: Any, out: dict[str, Any]) -> None:
+        if isinstance(value, BaseModel):
+            value = value.model_dump(mode="json", by_alias=True, exclude_unset=True)
+        if isinstance(value, dict):
+            for prop, v in value.items():
+                self._deep_object(f"{key}[{prop}]", v, out)
+        elif value is not None:
+            out[key] = value
+
+    _COLLECTION_DELIMITERS = {"csv": ",", "ssv": " ", "pipes": "|"}
+
+    #: Characters left literal in a cookie value: every RFC 6265 cookie-octet
+    #: except the `,` and `;` this client joins members on. A `=` stays literal
+    #: too — only the first one separates a cookie's name from its value.
+    _COOKIE_SAFE = "!#$%&'()*+-./:<>?@[]^_`{|}~="
+
+    def _scalar(self, value: Any) -> str:
+        # The wire form of a single parameter value: JSON spellings for bools,
+        # ISO-8601 for dates, and the model's own wire shape for anything else.
+        if isinstance(value, bool):
+            return "true" if value else "false"
+        if isinstance(value, (datetime.date, datetime.datetime)):
+            return value.isoformat()
+        dumped = self._dump(value)
+        if isinstance(dumped, str):
+            return dumped
+        # RFC 6570 renders a list as its comma-joined members and an object as
+        # comma-joined key,value pairs. Python's own `str` would emit a repr —
+        # `['a', 'b']`, quotes and spaces included.
+        if isinstance(dumped, list):
+            return ",".join(self._scalar(v) for v in dumped)
+        if isinstance(dumped, dict):
+            return ",".join(
+                f"{k},{self._scalar(v)}" for k, v in dumped.items() if v is not None
+            )
+        if dumped is None:
+            return ""
+        return str(dumped)
+
+    def _query(self, query_params: dict[str, Any], collection_formats: dict[str, str] | None = None) -> dict[str, Any]:
+        out: dict[str, Any] = {}
+        for key, value in query_params.items():
+            if value is None:
+                continue
+            fmt = (collection_formats or {}).get(key)
+            if fmt == "deepObject":
+                self._deep_object(key, value, out)
+            elif isinstance(value, list):
+                delimiter = self._COLLECTION_DELIMITERS.get(fmt or "multi")
+                if delimiter is None:
+                    out[key] = [self._scalar(v) for v in value]
+                else:
+                    out[key] = delimiter.join(self._scalar(v) for v in value)
+            elif self._is_object(value):
+                # OpenAPI's default query style is form/explode, under which an
+                # object expands to one parameter per property rather than
+                # being stringified.
+                for prop, prop_value in self._as_dict(value).items():
+                    if prop_value is not None:
+                        out[prop] = self._scalar(prop_value)
+            else:
+                out[key] = self._scalar(value)
+        return out
+
+    def _is_object(self, value: Any) -> bool:
+        return isinstance(value, (dict, BaseModel))
+
+    def _as_dict(self, value: Any) -> dict[str, Any]:
+        if isinstance(value, BaseModel):
+            return value.model_dump(mode="json", by_alias=True, exclude_unset=True)
+        return dict(value)
+
+    def _headers(
+        self,
+        header_params: dict[str, Any] | None = None,
+        collection_formats: dict[str, str] | None = None,
+        cookie_params: dict[str, Any] | None = None,
+    ) -> list[tuple[str, str]]:
+        out: list[tuple[str, str]] = []
+        for key, value in (header_params or {}).items():
+            if value is None:
+                continue
+            if isinstance(value, list):
+                fmt = (collection_formats or {}).get(key, "csv")
+                delimiter = self._COLLECTION_DELIMITERS.get(fmt)
+                if delimiter is None:
+                    for item in value:
+                        out.append((key, self._scalar(item)))
+                else:
+                    out.append((key, delimiter.join(self._scalar(v) for v in value)))
+            else:
+                out.append((key, self._scalar(value)))
+        # A config header only applies where the operation didn't set one:
+        # httpx comma-joins repeated names, which would corrupt the value.
+        operation_headers = {key.lower() for key, _ in out}
+        out.extend(
+            (key, value)
+            for key, value in self._config.headers.items()
+            if key.lower() not in operation_headers
+        )
+        # The operation's cookies are merged into one `Cookie` header alongside
+        # every other source. Passing them to httpx's `cookies=` instead would
+        # drop them outright whenever a `Cookie` header is present, since
+        # http.cookiejar skips a request that already carries one — and setting
+        # the header here would in turn shadow the caller's own jar and header,
+        # which httpx resolves in favour of the more specific value.
+        cookies = self._cookies(cookie_params or {})
+        if cookies:
+            pairs = [
+                *(
+                    value
+                    for source in (self._client.headers, dict(out))
+                    for key, value in source.items()
+                    if key.lower() == "cookie"
+                ),
+                *(f"{key}={value}" for key, value in self._client.cookies.items()),
+                *(f"{key}={value}" for key, value in cookies.items()),
+            ]
+            out = [(key, value) for key, value in out if key.lower() != "cookie"]
+            out.append(("Cookie", "; ".join(pairs)))
+        return out
+
+    def _default_content_type(
+        self, header_params: dict[str, Any], media_type: str
+    ) -> None:
+        # The media type the specification declares, applied unless the operation
+        # takes a Content-Type of its own and the caller supplied one. Header
+        # names are case-insensitive, and a declared header the caller omitted is
+        # present holding `None` — neither counts as the caller setting it.
+        if any(
+            key.lower() == "content-type" and value is not None
+            for key, value in header_params.items()
+        ):
+            return
+        for key in list(header_params):
+            if key.lower() == "content-type":
+                header_params[key] = media_type
+                return
+        header_params["Content-Type"] = media_type
+
+    def _cookies(self, cookie_params: dict[str, Any]) -> dict[str, str]:
+        out: dict[str, str] = {}
+        for key, value in cookie_params.items():
+            if value is None:
+                continue
+            dumped = self._dump(value)
+            # A cookie uses form-style expansion, so a list joins on `,` and an
+            # object on `,` between each key and value. Members are encoded so a
+            # `;` or `,` inside one can't be read as a delimiter, while the
+            # joining commas stay literal.
+            if isinstance(dumped, list):
+                rendered = ",".join(self._cookie_value(v) for v in dumped)
+            elif isinstance(dumped, dict):
+                rendered = ",".join(
+                    self._cookie_value(k) + "," + self._cookie_value(v)
+                    for k, v in dumped.items()
+                    if v is not None
+                )
+            else:
+                rendered = self._cookie_value(value)
+            out[key] = rendered
+        return out
+
+    def _cookie_value(self, value: Any) -> str:
+        # Only the characters a cookie parser treats as structure are escaped, so
+        # a timestamp keeps its colons and a base64 token its `=` padding. Servers
+        # do not URL-decode cookies, so anything escaped here arrives escaped.
+        return quote(self._scalar(value), safe=self._COOKIE_SAFE)
+
+    def _dump(self, value: Any) -> Any:
+        if value is None:
+            return None
+        if isinstance(value, BaseModel):
+            return value.model_dump(mode="json", by_alias=True, exclude_unset=True)
+        if isinstance(value, (list, tuple)):
+            return [self._dump(v) for v in value]
+        if isinstance(value, dict):
+            return {k: self._dump(v) for k, v in value.items()}
+        if isinstance(value, (datetime.date, datetime.datetime)):
+            return value.isoformat()
+        return value
+
+<%_ if (hasAllowReservedParams) { _%>
+    <%- kw.def %> _send_with_url(self, final_url: str, **kwargs: Any) -> httpx.Response:
+        # `request()` lets httpx rebuild the query from the client's params,
+        # discarding a hand-built one. Building the request first and overriding
+        # the URL keeps it, while auth and event hooks still run on send.
+        request = self._client.build_request(**kwargs)
+        request.url = httpx.URL(final_url)
+        return <%- kw.await %>self._client.send(request)
+
+    @<%- contextManager %>
+    <%- kw.def %> _stream_with_url(
+        self, final_url: str, **kwargs: Any
+    ) -> <%- contextAbc %>[httpx.Response]:
+        # The streaming counterpart of `_send_with_url`: `stream()` would rebuild
+        # the query from the client's params and percent-encode a hand-built one.
+        request = self._client.build_request(**kwargs)
+        request.url = httpx.URL(final_url)
+        response = <%- kw.await %>self._client.send(request, stream=True)
+        try:
+            yield response
+        finally:
+            <%- kw.await %>response.<%- hx.close %>()
+
+<%_ } _%>
+<%_ if (hasMultipartBody) { _%>
+    def _is_file_part(self, value: Any) -> bool:
+        # httpx reads a file part as (filename, content[, content_type]), so a
+        # tuple only qualifies in that shape — a `prefixItems` field is a tuple
+        # too, and passing one to httpx as a file raises a TypeError.
+        if isinstance(value, tuple):
+            return 2 <= len(value) <= 3 and isinstance(value[0], (str, type(None)))
+        return hasattr(value, "read") or isinstance(value, (bytes, bytearray))
+
+    def _multipart(
+        self,
+        fields: dict[str, Any],
+        part_content_types: dict[str, str] | None = None,
+    ) -> list[tuple[str, Any]]:
+        # Every field becomes an httpx `files=` part: binary values stream as
+        # file parts (one per element for a list) and everything else is sent as
+        # text, with structured values JSON encoded. Text fields go through
+        # `files=` rather than `data=` because httpx only chooses multipart when
+        # a file part is present, and only `files=` carries a per-part content
+        # type from the request body's `encoding` object.
+        parts: list[tuple[str, Any]] = []
+        for key, value in fields.items():
+            content_type = (part_content_types or {}).get(key)
+            values = value if isinstance(value, list) else [value]
+            if any(self._is_file_part(item) for item in values):
+                parts.extend(
+                    (key, item if content_type is None else (None, item, content_type))
+                    for item in values
+                )
+                continue
+            for item in values:
+                text = self._part_text(self._dump(item))
+                parts.append(
+                    (key, (None, text) if content_type is None else (None, text, content_type))
+                )
+        return parts
+
+    def _part_text(self, value: Any) -> str:
+        if isinstance(value, bool):
+            return "true" if value else "false"
+        if isinstance(value, str):
+            return value
+        if value is None or isinstance(value, (int, float)):
+            return "" if value is None else str(value)
+        return json.dumps(value, separators=(",", ":"))
+
+<%_ } _%>
+<%_ if (hasMultiMediaResponse) { _%>
+    def _json_body(self, response: httpx.Response) -> Any:
+        # A response declaring JSON alongside another media type can arrive as
+        # either, and a declared-JSON body can arrive empty (a 200 with no
+        # content). Both would raise a bare JSONDecodeError out of the client, so
+        # the text is handed over instead.
+        if not response.content:
+            return None
+        try:
+            return response.json()
+        except ValueError:
+            return response.text
+
+<%_ } _%>
+    def _error_payload(self, response: httpx.Response) -> Any:
+        # An error body is whatever the server actually sent, which need not be
+        # the JSON the spec declares (a proxy's HTML page, say).
+        try:
+            return response.json()
+        except ValueError:
+            return response.text
+
+    def _error(self, wrapper: type[_ErrorT], status: int, payload: Any) -> _ErrorT:
+        # Coerce to the declared error type, falling back to the raw payload so
+        # a body that doesn't match the spec still raises the typed exception.
+        try:
+            return wrapper.model_validate({"status": status, "error": payload})
+        except ValidationError:
+            return wrapper.model_construct(status=status, error=payload)
+<%_ allOperations.forEach((op) => {
+  const shape = op.requestShape ?? { inputs: [] };
+  const pathInputs = inputsByKind(op, 'path');
+  const queryInputs = inputsByKind(op, 'query');
+  const headerInputs = inputsByKind(op, 'header');
+  const cookieInputs = inputsByKind(op, 'cookie');
+  const bodyFieldInputs = inputsByKind(op, 'body-field');
+  const wholeBodyInputs = inputsByKind(op, 'body');
+  const queryCollectionInputs = queryInputs.filter(k => k.source.collectionFormat);
+  const headerCollectionInputs = headerInputs.filter(k => k.source.collectionFormat);
+  const bodyMediaType = (shape.bodyFromFields && shape.bodyFromFields.mediaType)
+    || (shape.bodyAsSingleInput && shape.bodyAsSingleInput.mediaType)
+    || undefined;
+  const bodyIsBinary = wholeBodyInputs.length === 1 && wholeBodyInputs[0].model.type === 'binary';
+  const bodyIsMultipart = bodyMediaType === 'multipart/form-data';
+  const bodyIsUrlEncoded = bodyMediaType === 'application/x-www-form-urlencoded';
+  // A body is JSON-encoded only when its media type says so. Anything else
+  // (text/plain, application/xml, ...) carries its own encoding, so a primitive
+  // is sent verbatim rather than wrapped in JSON quotes.
+  const bodyIsJsonWire = !bodyMediaType || isJsonMediaType(bodyMediaType);
+  // A scalar body under a non-JSON media type is sent verbatim. An enum is a
+  // scalar on the wire without being `isPrimitive`, so it is admitted too.
+  const bodyIsScalarNonJson = !bodyIsJsonWire
+    && wholeBodyInputs.length === 1
+    && (wholeBodyInputs[0].model.isPrimitive
+      || wholeBodyInputs[0].model.isEnum
+      || isPythonScalarType(wholeBodyInputs[0].model));
+  const contentJsonInputs = [...queryInputs, ...headerInputs, ...cookieInputs].filter(k => k.model.mediaType === 'application/json');
+  const styledPathInputs = pathInputs.filter(k => k.model.pathStyle);
+  const reservedInputs = queryInputs.filter(k => k.model.allowReserved);
+  const partContentTypes = (op.parametersBody && op.parametersBody.partContentTypes) || undefined;
+  // Whether the operation writes a Content-Type into `header_params`, which is
+  // also what declares it. A whole binary body is sent as raw content even under
+  // a form media type, so it sets the header httpx would otherwise derive from
+  // the multipart body it is not building.
+  const sendsContentType = !!bodyMediaType && (bodyIsBinary || !bodyIsMultipart);
+  // `_headers` also takes the cookies, since it merges them into `Cookie`.
+  // Keyword form, so each argument is independent of the others being present.
+  const headerArgs = [
+    headerInputs.length > 0 || sendsContentType ? 'header_params' : '',
+    headerCollectionInputs.length > 0 ? 'collection_formats=header_formats' : '',
+    cookieInputs.length > 0 ? 'cookie_params=cookie_params' : '',
+  ].filter(Boolean).join(', ');
+  const hasTag = (op.tags && op.tags.length > 0);
+  const methodPrefix = hasTag ? '_' : '';
+_%>
+
+    <%- kw.def %> <%- methodPrefix %><%- op.pythonMethodName %>(
+        <%- signature(op) %>,
+    ) -> <%- resultTypeFor(op) %>:
+<%- methodDocstring(op, '        ') %><%_ if (op.deprecated) { _%>
+        warnings.warn(
+            "`<%- op.pythonMethodName %>` is deprecated.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+<%_ } _%>
+<%_ if (pathInputs.length > 0) { _%>
+        path_params: dict[str, Any] = {<%_ pathInputs.forEach((k, i) => { _%><%- i > 0 ? ', ' : '' %><%- pyStr(k.source.wireName) %>: <%- k.pythonName %><%_ }); _%>}
+<%_ } _%>
+<%_ if (queryInputs.length > 0) { _%>
+        query_params: dict[str, Any] = {<%_ queryInputs.forEach((k, i) => { _%><%- i > 0 ? ', ' : '' %><%- pyStr(k.source.wireName) %>: <%- k.pythonName %><%_ }); _%>}
+<%_ } _%>
+<%_ if (headerInputs.length > 0 || sendsContentType) { _%>
+        header_params: dict[str, Any] = {<%_ headerInputs.forEach((k, i) => { _%><%- i > 0 ? ', ' : '' %><%- pyStr(k.source.wireName) %>: <%- k.pythonName %><%_ }); _%>}
+<%_ } _%>
+<%_ if (cookieInputs.length > 0) { _%>
+        cookie_params: dict[str, Any] = {<%_ cookieInputs.forEach((k, i) => { _%><%- i > 0 ? ', ' : '' %><%- pyStr(k.source.wireName) %>: <%- k.pythonName %><%_ }); _%>}
+<%_ } _%>
+<%_ /* A content-based parameter (declared with `content` rather than
+       `schema`) is serialised to its media type — JSON — as a single value. */ _%>
+<%_ contentJsonInputs.forEach((k) => {
+  const params = k.source.kind === 'query' ? 'query_params' : k.source.kind === 'header' ? 'header_params' : 'cookie_params'; _%>
+        if <%- params %>[<%- pyStr(k.source.wireName) %>] is not None:
+            <%- params %>[<%- pyStr(k.source.wireName) %>] = json.dumps(
+                self._dump(<%- params %>[<%- pyStr(k.source.wireName) %>]), separators=(",", ":")
+            )
+<%_ }); _%>
+<%_ /* Query and header formats are kept apart: a query and a header parameter
+       may share a name while declaring different collection formats. */ _%>
+<%_ if (queryCollectionInputs.length > 0) { _%>
+        query_formats: dict[str, str] | None = {<%_ queryCollectionInputs.forEach((k, i) => { _%><%- i > 0 ? ', ' : '' %><%- pyStr(k.source.wireName) %>: <%- pyStr(k.source.collectionFormat) %><%_ }); _%>}
+<%_ } _%>
+<%_ if (headerCollectionInputs.length > 0) { _%>
+        header_formats: dict[str, str] | None = {<%_ headerCollectionInputs.forEach((k, i) => { _%><%- i > 0 ? ', ' : '' %><%- pyStr(k.source.wireName) %>: <%- pyStr(k.source.collectionFormat) %><%_ }); _%>}
+<%_ } _%>
+<%_ if (shape.bodyFromFields) { _%>
+        _body_fields: dict[str, Any] = {}
+<%_ bodyFieldInputs.forEach((k) => {
+  if (k.isRequired) { _%>
+        _body_fields[<%- pyStr(k.source.fieldName) %>] = <%- k.pythonName %>
+<%_ } else { _%>
+        if <%- k.pythonName %> is not None:
+            _body_fields[<%- pyStr(k.source.fieldName) %>] = <%- k.pythonName %>
+<%_ } }); _%>
+<%_ if (shape.bodyFromFields.mediaType === 'multipart/form-data') { _%>
+        # httpx populates the Content-Type (and boundary) automatically when
+        # `files=` or `data=` is supplied; binary values stream as file parts.
+        _files = self._multipart(_body_fields<%_ if (partContentTypes) { _%>, {<%_ Object.entries(partContentTypes).forEach(([prop, ct], i) => { _%><%- i > 0 ? ', ' : '' %><%- pyStr(prop) %>: <%- pyStr(ct) %><%_ }); _%>}<%_ } _%>)
+        request_kwargs: dict[str, Any] = {"files": _files}
+<%_ } else if (shape.bodyFromFields.mediaType === 'application/x-www-form-urlencoded') { _%>
+        # httpx URL-encodes `data=` as form key=value pairs (arrays as
+        # repeated keys); None fields were already omitted above.
+        request_kwargs: dict[str, Any] = {"data": {k: self._dump(v) for k, v in _body_fields.items()}}
+<%_ } else { _%>
+        body = types.<%- shape.bodyFromFields.model.pythonClassName %>.model_validate(
+            _body_fields
+        ).model_dump(mode="json", by_alias=True, exclude_unset=True)
+        request_kwargs: dict[str, Any] = {"json": body}
+<%_ if (shape.bodyFromFields.mediaType) { _%>
+        if not self._config.omit_content_type_header:
+            self._default_content_type(header_params, "<%- shape.bodyFromFields.mediaType %>")
+<%_ } _%>
+<%_ } _%>
+<%_ } else if (wholeBodyInputs.length > 0) { _%>
+<%_ if (bodyIsBinary) { _%>
+        body = <%- wholeBodyInputs[0].pythonName %>
+        request_kwargs: dict[str, Any] = {"content": body}
+<%_ if (bodyMediaType) { _%>
+        if body is not None and not self._config.omit_content_type_header:
+            self._default_content_type(header_params, "<%- bodyMediaType %>")
+<%_ } _%>
+<%_ } else if (bodyIsMultipart) { _%>
+        body = <%- wholeBodyInputs[0].pythonName %>
+        # httpx populates the Content-Type (and boundary) automatically
+        # when `files=` or `data=` is supplied.
+        if isinstance(body, BaseModel):
+            body = body.model_dump(mode="python", by_alias=True, exclude_unset=True)
+        if isinstance(body, dict):
+            request_kwargs: dict[str, Any] = {"files": self._multipart(body)}
+        else:
+            request_kwargs = {"files": body}
+<%_ } else if (bodyIsUrlEncoded && !wholeBodyInputs[0].model.isPrimitive) { _%>
+        body = <%- wholeBodyInputs[0].pythonName %>
+        # httpx URL-encodes `data=` as form key=value pairs (arrays as
+        # repeated keys).
+        _form = self._dump(body)
+        request_kwargs: dict[str, Any] = {"data": {k: v for k, v in (_form or {}).items() if v is not None}}
+<%_ } else if (bodyIsUrlEncoded) { _%>
+        # A primitive urlencoded body (e.g. a raw pre-encoded string) is sent
+        # verbatim; only object bodies are form-encoded.
+        body = <%- wholeBodyInputs[0].pythonName %>
+        request_kwargs: dict[str, Any] = {"content": None if body is None else str(body)}
+        if body is not None and not self._config.omit_content_type_header:
+            self._default_content_type(header_params, "<%- bodyMediaType %>")
+<%_ } else if (bodyIsScalarNonJson) { _%>
+        # A scalar under a non-JSON media type is its own encoding, so it is
+        # sent as-is rather than JSON-encoded.
+        body = <%- wholeBodyInputs[0].pythonName %>
+        request_kwargs: dict[str, Any] = {"content": None if body is None else str(body)}
+        if body is not None and not self._config.omit_content_type_header:
+            self._default_content_type(header_params, "<%- bodyMediaType %>")
+<%_ } else if (wholeBodyInputs[0].isRequired && wholeBodyInputs[0].isNullable) { _%>
+        # The body is required and may be null, so `None` is the JSON value
+        # `null` rather than an absent body — httpx omits `json=None` entirely,
+        # which a server cannot tell from no body at all.
+        body = self._dump(<%- wholeBodyInputs[0].pythonName %>)
+        request_kwargs: dict[str, Any] = (
+            {"content": b"null"} if body is None else {"json": body}
+        )
+        if not self._config.omit_content_type_header:
+            self._default_content_type(header_params, "<%- bodyMediaType || 'application/json' %>")
+<%_ } else { _%>
+        body = self._dump(<%- wholeBodyInputs[0].pythonName %>)
+        request_kwargs: dict[str, Any] = {"json": body}
+<%_ if (bodyMediaType) { _%>
+        if body is not None and not self._config.omit_content_type_header:
+            self._default_content_type(header_params, "<%- bodyMediaType %>")
+<%_ } _%>
+<%_ } _%>
+<%_ } else { _%>
+        request_kwargs: dict[str, Any] = {}
+<%_ } _%>
+<%_ if (reservedInputs.length > 0) { _%>
+<%_ /* allowReserved query parameters keep reserved characters literal, so the
+       query string is built manually and appended to the URL — httpx would
+       percent-encode values passed via `params=`. */ _%>
+        _qs = self._query_string(<%- queryInputs.length > 0 ? "query_params" : "{}" %>, <%- queryCollectionInputs.length > 0 ? "query_formats" : "None" %>, {<%_ reservedInputs.forEach((k, i) => { _%><%- i > 0 ? ', ' : '' %><%- pyStr(k.source.wireName) %><%_ }); _%>})
+        _request_url = <%- urlExpr(op, pathInputs, styledPathInputs) %> + ("?" + _qs if _qs else "")
+<%_ } else { _%>
+        _request_url = <%- urlExpr(op, pathInputs, styledPathInputs) %>
+<%_ } _%>
+<%_ if (op.isStreaming) { _%>
+<%_ if (reservedInputs.length === 0) { _%>
+        <%- kw.with %> self._client.stream(
+            "<%- op.method %>",
+            _request_url,
+<%_ if (queryInputs.length > 0) { _%>
+            params=self._query(query_params<%- queryCollectionInputs.length > 0 ? ", query_formats" : "" %>),
+<%_ } _%>
+<%_ } else { _%>
+        <%- kw.with %> self._stream_with_url(
+            _request_url,
+            method="<%- op.method %>",
+            url=_request_url,
+<%_ } _%>
+            headers=self._headers(<%- headerArgs %>),
+            **request_kwargs,
+        ) as response:
+<%_ op.responses.forEach((resp) => {
+  const isResult = isSuccessResponse(op, resp);
+  const cond = branchCondition(op, resp);
+_%>
+<%_ /* A branch body is indented one level under its status check; an
+       unconditional branch sits at the enclosing level instead. */ _%>
+<%_ const ind = cond ? '                ' : '            '; _%>
+<%_ if (cond) { _%>
+            if <%- cond %>:
+<%_ } _%>
+<%_ if (isResult && resp.isJsonlStreaming) { _%>
+                buffer = ""
+                <%- kw.for %> chunk in response.<%- hx.iterText %>():
+                    buffer += chunk
+                    while "\n" in buffer:
+                        line, buffer = buffer.split("\n", 1)
+                        # `iter_text` doesn't translate newlines, so a CRLF
+                        # stream leaves a trailing carriage return on each line.
+                        line = line.rstrip("\r")
+                        if line.strip():
+                            yield <%- streamItemParseExpr(resp.itemSchemaModel, "line") %>
+                if buffer.strip():
+                    yield <%- streamItemParseExpr(resp.itemSchemaModel, "buffer") %>
+                return
+<%_ } else if (isResult) { _%>
+                <%- kw.for %> line in response.<%- hx.iterLines %>():
+                    if line:
+                        yield <%- streamChunkParseExpr(resp, "line") %>
+                return
+<%_ } else { _%>
+<%- ind %><%- kw.await %>response.<%- hx.read %>()
+<%- ind %><%- renderTypedRaise(op, resp) %>
+<%_ } _%>
+<%_ }); _%>
+<%_ if (!hasUnconditionalBranch(op)) { _%>
+            <%- kw.await %>response.<%- hx.read %>()
+            raise <%- op.errorShape.exceptionClassName %>(response.status_code, None)
+<%_ } _%>
+<%_ } else { _%>
+<%_ if (reservedInputs.length === 0) { _%>
+        response = <%- kw.await %>self._client.request(
+            "<%- op.method %>",
+            _request_url,
+<%_ if (queryInputs.length > 0) { _%>
+            params=self._query(query_params<%- queryCollectionInputs.length > 0 ? ", query_formats" : "" %>),
+<%_ } _%>
+<%_ } else { _%>
+        response = <%- kw.await %>self._send_with_url(
+            _request_url,
+            method="<%- op.method %>",
+            url=_request_url,
+<%_ } _%>
+            headers=self._headers(<%- headerArgs %>),
+            **request_kwargs,
+        )
+<%_ op.responses.forEach((resp) => {
+  const isSuccess = isSuccessResponse(op, resp);
+  const cond = branchCondition(op, resp);
+_%>
+<%_ const ind = cond ? '            ' : '        '; _%>
+<%_ if (cond) { _%>
+        if <%- cond %>:
+<%_ } _%>
+<%- ind %><%- isSuccess ? `return ${responseParseExpr(resp)}` : renderTypedRaise(op, resp) %>
+<%_ }); _%>
+<%_ if (!hasUnconditionalBranch(op)) { _%>
+        raise <%- op.errorShape.exceptionClassName %>(response.status_code, None)
+<%_ } _%>
+<%_ } _%>
+<%_ }); _%>
+<%_ // ────── Tag namespaces ────── _%>
+<%_ Object.entries(tagGroups).forEach(([tag, ops]) => { _%>
+
+
+class <%- pythonClassNameForTag(tag) %>:
+    """`<%- tag %>` operations."""
+
+    def __init__(self, parent: <%- clientClassName %>) -> None:
+        self._parent = parent
+<%_ ops.forEach((op) => {
+  const inputs = op.requestShape?.inputs ?? [];
+  // A streaming delegate is a plain `def` handing back the inner generator, so
+  // closing it reaches that generator: `yield from` forwards `close()`, and
+  // returning the async generator forwards `aclose()`. An `async def` that
+  // re-yielded would wrap it in a second generator `aclose()` never reaches,
+  // holding the connection open until garbage collection.
+  const delegateDef = isAsync && !op.isStreaming ? 'async def' : 'def';
+  const delegate = op.isStreaming
+    ? (isAsync ? 'return ' : 'yield from ')
+    : `return ${kw.await}`;
+_%>
+
+    <%- signature(op).replace(/^self/, `${delegateDef} ${op.pythonMethodName}(\n        self`) %>,
+    ) -> <%- resultTypeFor(op) %>:
+<%- methodDocstring(op, '        ') _%>
+        <%- delegate %>self._parent._<%- op.pythonMethodName %>(
+<%_ if (isPositionalBody(op)) { _%>
+            <%- inputs[0].pythonName %>,
+<%_ } else { _%>
+<%_ inputs.forEach((k) => { _%>
+            <%- k.pythonName %>=<%- k.pythonName %>,
+<%_ }); _%>
+<%_ } _%>
+        )
+<%_ }); _%>
+<%_ }); _%>