@aws/nx-plugin 1.0.0 → 1.0.2

package/src/open-api/py-client/files/shared/__init__.py.template

@@ -0,0 +1,28 @@
+"""<%- className %> client — AUTO-GENERATED, do not edit."""
+
+from . import types as types
+from .errors import ApiError as ApiError
+<%_ if (clientType === 'sync' || clientType === 'both') { _%>
+from .client import <%- className %> as <%- className %>
+from .client import <%- className %>Config as <%- className %>Config
+<%_ } _%>
+<%_ if (clientType === 'async' || clientType === 'both') { _%>
+from .async_client import Async<%- className %> as Async<%- className %>
+from .async_client import Async<%- className %>Config as Async<%- className %>Config
+<%_ } _%>
+
+# `ApiError` catches any failure from either client. The per-operation
+# subclasses in `.errors` narrow `.error` to the responses one operation
+# declares — import them from there when you want that.
+__all__ = [
+<%_ if (clientType === 'sync' || clientType === 'both') { _%>
+    "<%- className %>",
+    "<%- className %>Config",
+<%_ } _%>
+<%_ if (clientType === 'async' || clientType === 'both') { _%>
+    "Async<%- className %>",
+    "Async<%- className %>Config",
+<%_ } _%>
+    "ApiError",
+    "types",
+]

package/src/open-api/py-client/files/shared/errors.py.template

@@ -0,0 +1,37 @@
+<%_ // An operation with no error responses has `Never` as its error type. _%>
+<%_ const hasNeverErrorType = allOperations.some(op => !op.errorShape || op.errorShape.entries.length === 0); _%>
+"""Errors raised by <%- className %> — AUTO-GENERATED, do not edit."""
+
+from __future__ import annotations
+
+from typing import Any<%- hasNeverErrorType ? ', Never' : '' %>
+
+from . import types
+
+
+class ApiError(Exception):
+    """Base class for all API errors.
+
+    Subclasses are generated per-operation so `error` can be narrowed by the
+    type checker via `isinstance` or `match`. Catch `ApiError` to handle any
+    status code across operations, from either the sync or the async client.
+    """
+
+    status: int
+    error: Any
+
+    def __init__(self, status: int, error: Any = None) -> None:
+        super().__init__(f"API returned status {status}")
+        self.status = status
+        self.error = error
+
+<%_ allOperations.forEach((op) => {
+  const shape = op.errorShape;
+_%>
+
+
+class <%- shape.exceptionClassName %>(ApiError):
+    """Raised when `<%- op.operationIdSnakeCase || op.name %>` returns a non-success status."""
+
+    error: <% if (shape.entries.length === 0) { %>Never<% } else { %>types.<%- shape.unionTypeName %><% } %>
+<%_ }); _%>

package/src/open-api/py-client/files/shared/types.py.template

@@ -0,0 +1,319 @@
+<%_
+// An operation with no error responses has `Never` as its error type.
+const hasNeverErrorType = allOperations.some(op => !op.errorShape || op.errorShape.entries.length === 0);
+const pyEnumValue = (member) => toPythonLiteral(member.value);
+/**
+ * A discriminated subtype's tag property. pydantic dispatches a tagged union
+ * on a bare `Literal` field that every member declares, so the tag is emitted
+ * as required whether or not the schema lists it in `required`: its value is
+ * fixed by union membership, and a missing tag is a request the server always
+ * rejects.
+ */
+const isDiscriminatorTag = (prop) => !!prop.discriminatorValue;
+
+/**
+ * Render text from the spec as a Python docstring body. A description is
+ * arbitrary text: a backslash would start an escape sequence and a trailing one
+ * would escape the closing quotes, so it goes through the same escaping as any
+ * other literal, with the surrounding quotes stripped.
+ */
+const pyDocstring = (text) =>
+  toPythonLiteral(String(text ?? '').replace(/\r?\n/g, ' ')).slice(1, -1);
+
+/** A model's docstring text, noting deprecation where the spec declares it. */
+const modelDocstring = (model) =>
+  pyDocstring(model.description || '') + (model.deprecated ? ' (deprecated)' : '');
+
+/**
+ * A 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 there is nothing to say.
+ */
+const docstring = (text, indent) => {
+  const body = String(text ?? '');
+  if (!body) return '';
+  const oneLine = `${indent}"""${body}"""`;
+  if (oneLine.length <= 120) return `${oneLine}\n`;
+  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`;
+};
+
+/** A model's docstring, wrapped as above. */
+const docstringBlock = (model, indent) =>
+  model.description || model.deprecated
+    ? docstring(modelDocstring(model), indent)
+    : '';
+
+const fieldAnnotation = (prop) => {
+  let base;
+  if (prop.isEnum && Array.isArray(prop.enum) && prop.enum.length > 0) {
+    base = `Literal[${prop.enum.map(pyEnumValue).join(', ')}]`;
+  } else {
+    base = prop.pythonType || 'Any';
+  }
+  if (isDiscriminatorTag(prop)) return base;
+  if (!prop.isRequired || prop.isNullable) return `${base} | None`;
+  return base;
+};
+
+/**
+ * Render a pydantic `Field(...)` call for a model property — alias, default,
+ * description, deprecated, frozen.  Returns null when no Field(...) is needed
+ * so the template can emit a bare `name: T` or `name: T = None`.
+ */
+const fieldCallFor = (property) => {
+  const snake = property.pythonName || property.name;
+  const aliasNeeded = snake !== property.name;
+  const args = [];
+  const needsDefault = !isDiscriminatorTag(property) && !property.isRequired;
+  if (needsDefault) args.push('default=None');
+  if (aliasNeeded) args.push(`alias=${toPythonLiteral(property.name)}`);
+  if (property.description) {
+    args.push(`description=${toPythonLiteral(property.description.replace(/\r?\n/g, ' '))}`);
+  }
+  if (property.isReadOnly) args.push('frozen=True');
+  if (property.deprecated) args.push('deprecated=True');
+  // Only emit Field(...) if something beyond a bare type annotation is needed.
+  if (args.length === 0) return null;
+  // If the only argument is default=None and there is no alias/desc/frozen/deprecated,
+  // prefer the shorter `= None` form.
+  if (args.length === 1 && args[0] === 'default=None') return null;
+  return `Field(${args.join(', ')})`;
+};
+
+const renderProperty = (property) => {
+  const snake = property.pythonName || property.name;
+  const typeAnnotation = fieldAnnotation(property);
+  const fieldCall = fieldCallFor(property);
+  const needsDefault = !isDiscriminatorTag(property) && !property.isRequired;
+  if (fieldCall) {
+    return `    ${snake}: ${typeAnnotation} = ${fieldCall}`;
+  }
+  if (needsDefault) {
+    return `    ${snake}: ${typeAnnotation} = None`;
+  }
+  return `    ${snake}: ${typeAnnotation}`;
+};
+_%>
+"""Types for <%- className %> — AUTO-GENERATED, do not edit."""
+
+from __future__ import annotations
+
+import datetime
+from typing import Annotated, Any, Literal<%- hasNeverErrorType ? ', Never' : '' %>, TypedDict
+
+from pydantic import BaseModel, ConfigDict, Field
+
+<%_
+/**
+ * Classify a model by how it's rendered in the module.
+ *
+ * `class` models emit as `class Foo(BaseModel)` and are self-contained — they
+ * reference other types only via forward-ref-quoted annotations that pydantic
+ * resolves lazily.
+ *
+ * `alias` models emit as `Foo = A | B / Literal[...] / list[...] / ...`.
+ * These are module-level expressions evaluated at import time, so every
+ * type they reference must already be defined.  Emit them *after* all class
+ * definitions so `TypeAdapter(Foo)` can resolve references without relying
+ * on forward-ref strings.
+ */
+const classifyModel = (model) => {
+  if (model.isInlinedByAllOf) return 'skip';
+  if (model.export === 'enum') return 'alias';
+  if (model.export === 'one-of' || model.export === 'any-of') return 'alias';
+  // An object with no properties and no `additionalProperties` parses as a
+  // dictionary whose value type is the model itself, which would render as the
+  // self-referential `X = dict[str, X]`. It carries no value type at all, so it
+  // is emitted as an empty class — which is what the schema describes.
+  if (model.export === 'dictionary') {
+    const isEmptyObject =
+      !model.link &&
+      !model.hasAdditionalProperties &&
+      !model.hasPatternProperties &&
+      model.type === model.name;
+    return isEmptyObject ? 'class' : 'alias';
+  }
+  if (model.export === 'array') return 'alias';
+  if (model.export === 'tuple') return 'alias';
+  // `all-of` is rendered as a `BaseModel` subclass with flattened fields.
+  return 'class';
+};
+_%>
+
+<%_ /* ────── Pass 1: all class definitions ────── */ _%>
+<%_ models.forEach((model) => {
+  if (classifyModel(model) !== 'class') return;
+_%>
+<%_ if (model.export === 'all-of') {
+  // `effectiveProperties` is the shared flattening of the composition,
+  // recursing through members that are themselves allOf composites.
+  const flattened = model.effectiveProperties || [];
+_%>
+
+class <%- model.pythonClassName %>(BaseModel):
+<%- docstringBlock(model, '    ') %>    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+<%_ if (flattened.length === 0) { _%>
+    pass
+<%_ } _%>
+<%_ flattened.forEach((property) => { _%>
+<%- renderProperty(property) %>
+<%_ }); _%>
+<%_ } else { _%>
+
+class <%- model.pythonClassName %>(BaseModel):
+<%- docstringBlock(model, '    ') %>    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+<%_ if ((model.properties || []).length === 0 && !model.hasAdditionalProperties) { _%>
+    pass
+<%_ } _%>
+<%_ (model.properties || []).forEach((property) => { _%>
+<%- renderProperty(property) %>
+<%_ }); _%>
+<%_ } _%>
+<%_ }); _%>
+
+<%_
+/* ────── Pass 2: all non-class aliases ──────
+ * An alias is a module-level expression evaluated at import time, so unlike a
+ * class-body annotation (which `from __future__ import annotations` defers)
+ * every alias it references must already be bound. Emit them in dependency
+ * order via a topological sort: an alias that names another alias follows it.
+ * Classes are all defined above, so only alias-to-alias edges matter.
+ */
+const aliasModels = models.filter((m) => classifyModel(m) === 'alias');
+const aliasByClassName = new Map(aliasModels.map((m) => [m.pythonClassName, m]));
+/** The aliases the given alias's rendered type expression names. */
+const aliasDependencies = (model) => {
+  const rendered = model.export === 'enum'
+    ? ''
+    : [model.pythonType || '', ...(model.properties || []).map((p) => p.pythonType || '')].join(' ');
+  const found = new Set();
+  for (const identifier of rendered.match(/[A-Za-z_][A-Za-z0-9_]*/g) || []) {
+    const dependency = aliasByClassName.get(identifier);
+    if (dependency && dependency !== model) found.add(dependency);
+  }
+  return found;
+};
+const sortedAliasModels = [];
+const aliasState = new Map();
+const visitAlias = (model) => {
+  // 'visiting' marks a cycle: emit it where first reached and let the reference
+  // that closed the loop resolve against the earlier binding.
+  if (aliasState.get(model)) return;
+  aliasState.set(model, 'visiting');
+  for (const dependency of aliasDependencies(model)) {
+    visitAlias(dependency);
+  }
+  aliasState.set(model, 'done');
+  sortedAliasModels.push(model);
+};
+aliasModels
+  .slice()
+  .sort((a, b) => a.name.localeCompare(b.name))
+  .forEach(visitAlias);
+_%>
+<%_ sortedAliasModels.forEach((model) => { _%>
+
+<%_ if (model.export === 'enum') { _%>
+<%- model.pythonClassName %> = Literal[<%_ model.enum.forEach((m, i) => { _%><%- i > 0 ? ', ' : '' %><%- pyEnumValue(m) %><%_ }); _%>]
+<%- docstringBlock(model, '') %><%_ } else if (model.export === 'one-of' || model.export === 'any-of') { _%>
+<%_ /* Classes are already defined above, so references can be unquoted —
+       which matters here, since pydantic's `TypeAdapter(X)` resolves an alias
+       at runtime and cannot see through a string forward-ref. */ _%>
+<%_ /* A discriminated union renders as a pydantic tagged union so parsing
+       dispatches directly to the matching branch (never merging branches).
+       Requires every member to carry the discriminator as a Literal-typed
+       field; otherwise fall back to a plain union. */ _%>
+<%_ /* pydantic requires the tag to be a bare Literal field on every member,
+       else TypeAdapter construction fails at import time. `renderProperty`
+       emits a tag that way whether or not the schema requires it. */
+    const memberModels = (model.composedModels || []);
+    const isTagged = model.discriminator && memberModels.length > 0
+      && memberModels.length === model.properties.filter(p => !p.isPrimitive).length
+      && (model.composedPrimitives || []).length === 0
+      && memberModels.every(m => (m.properties || []).some(p =>
+           p.name === model.discriminator.propertyName && p.discriminatorValue)); _%>
+<%_ if (isTagged) { _%>
+<%- model.pythonClassName %> = Annotated[<%_ model.properties.forEach((p, i) => { _%><%- i > 0 ? ' | ' : '' %><%- p.pythonType || 'Any' %><%_ }); _%>, Field(discriminator="<%- model.discriminator.pythonPropertyName %>")]
+<%_ } else { _%>
+<%- model.pythonClassName %> = <% model.properties.forEach((p, i) => { %><%- i > 0 ? ' | ' : '' %><%- p.pythonType || 'Any' %><% }); %>
+<%_ } _%>
+<%- docstringBlock(model, '') %><%_ } else if (model.export === 'dictionary' || model.export === 'array' || model.export === 'tuple') { _%>
+<%- model.pythonClassName %> = <%- model.pythonType %>
+<%- docstringBlock(model, '') %><%_ } _%>
+<%_ }); _%>
+<%_ // ────── Per-operation request TypedDicts ────── _%>
+<%_ allOperations.forEach((op) => { _%>
+<%_ if (op.parameters && op.parameters.length > 0) { _%>
+<%_ const required = op.parameters.filter(p => p.isRequired); _%>
+<%_ const optional = op.parameters.filter(p => !p.isRequired); _%>
+<%_ if (required.length > 0 && optional.length === 0) { _%>
+
+class <%- op.pythonRequestTypeName %>(TypedDict):
+<%- docstring(pyDocstring(op.description || op.summary), '    ') %><%_ op.parameters.forEach((p) => { _%>
+    <%- p.pythonName %>: <%- p.pythonType || 'Any' %>
+<%_ }); _%>
+<%_ } else if (required.length === 0) { _%>
+
+class <%- op.pythonRequestTypeName %>(TypedDict, total=False):
+<%- docstring(pyDocstring(op.description || op.summary), '    ') %><%_ op.parameters.forEach((p) => { _%>
+    <%- p.pythonName %>: <%- p.pythonType || 'Any' %>
+<%_ }); _%>
+<%_ } else { _%>
+
+class <%- op.pythonRequestTypeName %>Required(TypedDict):
+<%_ required.forEach((p) => { _%>
+    <%- p.pythonName %>: <%- p.pythonType || 'Any' %>
+<%_ }); _%>
+
+
+class <%- op.pythonRequestTypeName %>(<%- op.pythonRequestTypeName %>Required, total=False):
+<%- docstring(pyDocstring(op.description || op.summary), '    ') %><%_ optional.forEach((p) => { _%>
+    <%- p.pythonName %>: <%- p.pythonType || 'Any' %>
+<%_ }); _%>
+<%_ } _%>
+<%_ } _%>
+<%_ }); _%>
+<%_ // ────── Per-operation error taxonomy ────── _%>
+<%_ allOperations.forEach((op) => {
+  const shape = op.errorShape;
+  if (!shape || shape.entries.length === 0) {
+_%>
+
+<%- shape.unionTypeName %> = Never
+<%_
+  } else {
+_%>
+<%_ shape.entries.forEach((entry) => {
+  // Inside types.py the error type is defined locally; strip the client
+  // module's `types.` prefix the response model's pythonClientType carries.
+  const payloadType = entry.responseModel.type === 'void'
+    ? 'None'
+    : (entry.responseModel.pythonClientType || 'Any').replace(/\btypes\./g, '');
+_%>
+
+class <%- entry.className %>(BaseModel):
+    """Error wrapper for <%- op.operationIdPascalCase %> status <%- entry.code %>."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    status: <%- entry.statusAnnotation %>
+    error: <%- payloadType %>
+<%_ }); _%>
+
+<%- shape.unionTypeName %> = <% shape.entries.forEach((e, i) => { %><%- i > 0 ? ' | ' : '' %><%- e.className %><% }); %>
+<%_ } _%>
+<%_ }); _%>

package/src/open-api/py-client/generator.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type Tree } from '@nx/devkit';
+import { type NxGeneratorInfo } from '../../utils/nx.js';
+import { type CodeGenData } from '../utils/codegen-data/types.js';
+import type { OpenApiPyClientGeneratorSchema } from './schema.js';
+export declare const OPEN_API_PY_CLIENT_GENERATOR_INFO: NxGeneratorInfo;
+/**
+ * Python packages a generated client imports at runtime. A generator that
+ * emits a client into a project spreads these into its own declaration and
+ * adds them to that project's pyproject.
+ */
+export declare const OPEN_API_PY_CLIENT_DEPENDENCIES: import("../../utils/declared-dependencies.js").DependencyDeclaration<readonly import("../../utils/declared-dependencies.js").DeclaredTsDependency<"@ag-ui/client" | "@ag-ui/core" | "@ag-ui/encoder" | "@biomejs/biome" | "@a2a-js/sdk" | "@aws/aws-distro-opentelemetry-node-autoinstrumentation" | "@opentelemetry/propagator-jaeger" | "minimatch" | "deepmerge-ts" | "mysql2" | "@aws-sdk/client-dynamodb" | "@aws-sdk/client-api-gateway" | "@aws-sdk/client-iam" | "@aws-sdk/client-bedrock-agentcore" | "@aws-sdk/client-bedrock-runtime" | "@aws-sdk/client-s3" | "@aws-sdk/client-sts" | "@aws-sdk/client-cognito-identity-provider" | "@aws-sdk/credential-providers" | "@aws-sdk/credential-provider-cognito-identity" | "@aws-sdk/client-secrets-manager" | "@aws-sdk/rds-signer" | "@smithy/server-apigateway" | "@smithy/server-node" | "@aws-lambda-powertools/logger" | "@aws-lambda-powertools/metrics" | "@aws-lambda-powertools/parameters" | "@aws-lambda-powertools/tracer" | "@aws-lambda-powertools/parser" | "@aws-sdk/client-appconfigdata" | "@middy/core" | "@nxlv/python" | "@nx-extend/terraform" | "nx" | "@nx/devkit" | "@nx/js" | "@nx/react" | "@nx/vite" | "@nx/vitest" | "@nx/workspace" | "create-nx-workspace" | "@swc-node/register" | "@swc/core" | "@modelcontextprotocol/sdk" | "@modelcontextprotocol/inspector" | "@ag-ui/a2ui-toolkit" | "@ag-ui/aws-strands" | "agent-chat-cli" | "@copilotkit/react-core" | "rxjs" | "@strands-agents/sdk" | "@tanstack/react-router" | "@tanstack/router-plugin" | "@tanstack/router-generator" | "@tanstack/virtual-file-routes" | "@tanstack/router-utils" | "@cloudscape-design/board-components" | "@cloudscape-design/chat-components" | "@cloudscape-design/components" | "@cloudscape-design/global-styles" | "@tanstack/react-query" | "@tanstack/react-query-devtools" | "@trpc/tanstack-react-query" | "@trpc/client" | "@trpc/server" | "@types/node" | "@types/aws-lambda" | "@types/cors" | "@types/pg" | "@types/ws" | "@types/express" | "@smithy/config-resolver" | "@smithy/node-config-provider" | "@smithy/node-http-handler" | "@smithy/types" | "@vitest/coverage-v8" | "@vitest/ui" | "@astrojs/react" | "@astrojs/starlight" | "astro" | "cookie" | "aws4fetch" | "aws-cdk" | "aws-cdk-lib" | "aws-xray-sdk-core" | "constructs" | "cors" | "chalk" | "class-variance-authority" | "cn" | "commander" | "electrodb" | "esbuild" | "event-source-polyfill" | "@types/event-source-polyfill" | "@prisma/adapter-mariadb" | "@prisma/adapter-pg" | "@prisma/client" | "ejs" | "@types/ejs" | "express" | "fast-glob" | "husky" | "fs-extra" | "@types/fs-extra" | "mariadb" | "mise" | "npm" | "npm-check-updates" | "oidc-client-ts" | "pg" | "prisma" | "react-oidc-context" | "react" | "react-dom" | "rolldown" | "rolldown-plugin-dts" | "shx" | "simple-git" | "source-map-support" | "starlight-blog" | "tailwindcss" | "@tailwindcss/vite" | "tsx" | "lucide-react" | "radix-ui" | "shadcn" | "tw-animate-css" | "vite" | "typescript" | "vitest" | "jsdom" | "zod" | "ws", Record<string, never>>[], readonly [{
+    readonly name: "httpx";
+}, {
+    readonly name: "pydantic";
+}]>;
+/**
+ * Generate a Python httpx-based client from an OpenAPI spec.
+ *
+ * Emits:
+ *  - types.py        — pydantic v2 models + per-op error classes and TypedDicts
+ *  - client.py       — sync  client (httpx.Client)      when clientType includes 'sync'
+ *  - async_client.py — async client (httpx.AsyncClient) when clientType includes 'async'
+ *
+ * The shape mirrors `open-api#ts-client`, but the two decide a few things
+ * separately rather than through shared code: this generator reads the neutral
+ * `requestShape` from `codegen-data`, while the TypeScript templates still
+ * compute inlining themselves. Where they differ today, for the same spec:
+ *
+ *  - A discriminated object body: TypeScript inlines its fields, Python passes
+ *    the body whole so marshalling can dispatch on the discriminator.
+ *  - A body carrying `additionalProperties`, a union, or `patternProperties`, or
+ *    a body property literally named `body`: TypeScript wraps, Python flattens.
+ *  - An optional (`required: false`) object body: Python flattens its required
+ *    fields into required keyword arguments, so the body is always sent.
+ *  - A primitive `application/json` body: TypeScript sends the raw text, Python
+ *    sends it JSON-encoded.
+ *  - The media type chosen for a body offering several: TypeScript prefers any
+ *    `+json` type, Python only an exact `application/json`.
+ *
+ * Migrating the TypeScript templates onto `requestShape` would collapse these
+ * into one decision; until then they are differences of behaviour, not of
+ * correctness, and are covered by this generator's own tests.
+ */
+export declare const openApiPyClientGenerator: (tree: Tree, options: OpenApiPyClientGeneratorSchema) => Promise<void>;
+/**
+ * Generate an OpenAPI Python client in the target directory
+ */
+export declare const generateOpenApiPyClient: (tree: Tree, data: CodeGenData, outputPath: string, clientType?: "sync" | "async" | "both") => void;
+export default openApiPyClientGenerator;

package/src/open-api/py-client/generator.js

@@ -0,0 +1,119 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */ import { generateFiles } from "@nx/devkit";
+import * as path from "path";
+import { declareDependencies } from "../../utils/declared-dependencies.js";
+import { formatFilesInSubtree } from "../../utils/format.js";
+import { updateGitIgnore } from "../../utils/git.js";
+import { addGeneratorMetricsIfApplicable } from "../../utils/metrics.js";
+import { getGeneratorInfo } from "../../utils/nx.js";
+import { buildOpenApiCodeGenerationData } from "../ts-client/generator.js";
+import { toPythonClassName, toPythonLiteral } from "../utils/codegen-data/languages.js";
+import { isPythonCollection, needsPythonTypeAdapter } from "../utils/codegen-data/types.js";
+import { annotatePythonData, assertNoClashingPythonNames } from "../utils/codegen-data.js";
+export const OPEN_API_PY_CLIENT_GENERATOR_INFO = getGeneratorInfo(import.meta.filename);
+/**
+ * Python packages a generated client imports at runtime. A generator that
+ * emits a client into a project spreads these into its own declaration and
+ * adds them to that project's pyproject.
+ */ export const OPEN_API_PY_CLIENT_DEPENDENCIES = declareDependencies()({
+    py: [
+        {
+            name: 'httpx'
+        },
+        {
+            name: 'pydantic'
+        }
+    ]
+});
+/**
+ * Generate a Python httpx-based client from an OpenAPI spec.
+ *
+ * Emits:
+ *  - types.py        — pydantic v2 models + per-op error classes and TypedDicts
+ *  - client.py       — sync  client (httpx.Client)      when clientType includes 'sync'
+ *  - async_client.py — async client (httpx.AsyncClient) when clientType includes 'async'
+ *
+ * The shape mirrors `open-api#ts-client`, but the two decide a few things
+ * separately rather than through shared code: this generator reads the neutral
+ * `requestShape` from `codegen-data`, while the TypeScript templates still
+ * compute inlining themselves. Where they differ today, for the same spec:
+ *
+ *  - A discriminated object body: TypeScript inlines its fields, Python passes
+ *    the body whole so marshalling can dispatch on the discriminator.
+ *  - A body carrying `additionalProperties`, a union, or `patternProperties`, or
+ *    a body property literally named `body`: TypeScript wraps, Python flattens.
+ *  - An optional (`required: false`) object body: Python flattens its required
+ *    fields into required keyword arguments, so the body is always sent.
+ *  - A primitive `application/json` body: TypeScript sends the raw text, Python
+ *    sends it JSON-encoded.
+ *  - The media type chosen for a body offering several: TypeScript prefers any
+ *    `+json` type, Python only an exact `application/json`.
+ *
+ * Migrating the TypeScript templates onto `requestShape` would collapse these
+ * into one decision; until then they are differences of behaviour, not of
+ * correctness, and are covered by this generator's own tests.
+ */ export const openApiPyClientGenerator = async (tree, options)=>{
+    const data = await buildOpenApiCodeGenerationData(tree, options.openApiSpecPath);
+    const clientType = options.clientType ?? 'both';
+    // Derived here rather than in the shared pipeline, so a TypeScript consumer of
+    // the same spec pays for neither these fields nor a Python-specific name clash.
+    annotatePythonData(data);
+    for (const model of data.models){
+        assertNoClashingPythonNames(model);
+    }
+    generateOpenApiPyClient(tree, data, options.outputPath, clientType);
+    // The client is regenerated from the spec, so it is ignored by default.
+    // Remove the entry to check it in instead.
+    updateGitIgnore(tree, '.', (patterns)=>[
+            ...patterns,
+            options.outputPath
+        ]);
+    await addGeneratorMetricsIfApplicable(tree, [
+        OPEN_API_PY_CLIENT_GENERATOR_INFO
+    ]);
+    await formatFilesInSubtree(tree);
+};
+/**
+ * Generate an OpenAPI Python client in the target directory
+ */ export const generateOpenApiPyClient = (tree, data, outputPath, clientType = 'both')=>{
+    // `toPythonLiteral` is shared with the type renderer so a value is escaped
+    // the same way wherever a template spells it out. The type predicates let a
+    // template ask what a Python type is, rather than matching its spelling.
+    const base = {
+        ...data,
+        // The shared `className` comes from the spec title via `toClassName`, which
+        // is a valid TypeScript name but not always a Python one: a title with no
+        // alphanumerics renders nothing (`class :`) and one spelt `None` renders a
+        // keyword. It also has to clear the names these modules export themselves,
+        // so a title of `ApiError` cannot shadow the base exception.
+        className: toPythonClassName(data.className),
+        clientType,
+        toPythonLiteral,
+        isPythonCollection,
+        needsPythonTypeAdapter
+    };
+    generateFiles(tree, path.join(import.meta.dirname, 'files', 'shared'), outputPath, base);
+    // Both clients render from one template: they differ only in how they await,
+    // and keeping two copies is how a fix lands in one and not the other.
+    // `clientModuleName` names the emitted file, `isAsync` selects the keywords.
+    const clientDir = path.join(import.meta.dirname, 'files', 'client');
+    if (clientType === 'sync' || clientType === 'both') {
+        generateFiles(tree, clientDir, outputPath, {
+            ...base,
+            isAsync: false,
+            clientModuleName: 'client'
+        });
+    }
+    if (clientType === 'async' || clientType === 'both') {
+        generateFiles(tree, clientDir, outputPath, {
+            ...base,
+            isAsync: true,
+            clientModuleName: 'async_client'
+        });
+    }
+};
+export default openApiPyClientGenerator;
+
+//# sourceMappingURL=generator.js.map

package/src/open-api/py-client/generator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../packages/nx-plugin/src/open-api/py-client/generator.ts"],"sourcesContent":["/**\n * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\nimport { generateFiles, type Tree } from '@nx/devkit';\nimport * as path from 'path';\nimport { declareDependencies } from '../../utils/declared-dependencies.js';\nimport { formatFilesInSubtree } from '../../utils/format.js';\nimport { updateGitIgnore } from '../../utils/git.js';\nimport { addGeneratorMetricsIfApplicable } from '../../utils/metrics.js';\nimport { getGeneratorInfo, type NxGeneratorInfo } from '../../utils/nx.js';\nimport { buildOpenApiCodeGenerationData } from '../ts-client/generator.js';\nimport {\n  toPythonClassName,\n  toPythonLiteral,\n} from '../utils/codegen-data/languages.js';\nimport {\n  type CodeGenData,\n  isPythonCollection,\n  needsPythonTypeAdapter,\n} from '../utils/codegen-data/types.js';\nimport {\n  annotatePythonData,\n  assertNoClashingPythonNames,\n} from '../utils/codegen-data.js';\nimport type { OpenApiPyClientGeneratorSchema } from './schema.js';\n\nexport const OPEN_API_PY_CLIENT_GENERATOR_INFO: NxGeneratorInfo =\n  getGeneratorInfo(import.meta.filename);\n\n/**\n * Python packages a generated client imports at runtime. A generator that\n * emits a client into a project spreads these into its own declaration and\n * adds them to that project's pyproject.\n */\nexport const OPEN_API_PY_CLIENT_DEPENDENCIES = declareDependencies()({\n  py: [{ name: 'httpx' }, { name: 'pydantic' }],\n});\n\n/**\n * Generate a Python httpx-based client from an OpenAPI spec.\n *\n * Emits:\n *  - types.py        — pydantic v2 models + per-op error classes and TypedDicts\n *  - client.py       — sync  client (httpx.Client)      when clientType includes 'sync'\n *  - async_client.py — async client (httpx.AsyncClient) when clientType includes 'async'\n *\n * The shape mirrors `open-api#ts-client`, but the two decide a few things\n * separately rather than through shared code: this generator reads the neutral\n * `requestShape` from `codegen-data`, while the TypeScript templates still\n * compute inlining themselves. Where they differ today, for the same spec:\n *\n *  - A discriminated object body: TypeScript inlines its fields, Python passes\n *    the body whole so marshalling can dispatch on the discriminator.\n *  - A body carrying `additionalProperties`, a union, or `patternProperties`, or\n *    a body property literally named `body`: TypeScript wraps, Python flattens.\n *  - An optional (`required: false`) object body: Python flattens its required\n *    fields into required keyword arguments, so the body is always sent.\n *  - A primitive `application/json` body: TypeScript sends the raw text, Python\n *    sends it JSON-encoded.\n *  - The media type chosen for a body offering several: TypeScript prefers any\n *    `+json` type, Python only an exact `application/json`.\n *\n * Migrating the TypeScript templates onto `requestShape` would collapse these\n * into one decision; until then they are differences of behaviour, not of\n * correctness, and are covered by this generator's own tests.\n */\nexport const openApiPyClientGenerator = async (\n  tree: Tree,\n  options: OpenApiPyClientGeneratorSchema,\n) => {\n  const data = await buildOpenApiCodeGenerationData(\n    tree,\n    options.openApiSpecPath,\n  );\n  const clientType = options.clientType ?? 'both';\n\n  // Derived here rather than in the shared pipeline, so a TypeScript consumer of\n  // the same spec pays for neither these fields nor a Python-specific name clash.\n  annotatePythonData(data);\n\n  for (const model of data.models) {\n    assertNoClashingPythonNames(model);\n  }\n\n  generateOpenApiPyClient(tree, data, options.outputPath, clientType);\n\n  // The client is regenerated from the spec, so it is ignored by default.\n  // Remove the entry to check it in instead.\n  updateGitIgnore(tree, '.', (patterns) => [...patterns, options.outputPath]);\n\n  await addGeneratorMetricsIfApplicable(tree, [\n    OPEN_API_PY_CLIENT_GENERATOR_INFO,\n  ]);\n\n  await formatFilesInSubtree(tree);\n};\n\n/**\n * Generate an OpenAPI Python client in the target directory\n */\nexport const generateOpenApiPyClient = (\n  tree: Tree,\n  data: CodeGenData,\n  outputPath: string,\n  clientType: 'sync' | 'async' | 'both' = 'both',\n) => {\n  // `toPythonLiteral` is shared with the type renderer so a value is escaped\n  // the same way wherever a template spells it out. The type predicates let a\n  // template ask what a Python type is, rather than matching its spelling.\n  const base = {\n    ...data,\n    // The shared `className` comes from the spec title via `toClassName`, which\n    // is a valid TypeScript name but not always a Python one: a title with no\n    // alphanumerics renders nothing (`class :`) and one spelt `None` renders a\n    // keyword. It also has to clear the names these modules export themselves,\n    // so a title of `ApiError` cannot shadow the base exception.\n    className: toPythonClassName(data.className),\n    clientType,\n    toPythonLiteral,\n    isPythonCollection,\n    needsPythonTypeAdapter,\n  };\n\n  generateFiles(\n    tree,\n    path.join(import.meta.dirname, 'files', 'shared'),\n    outputPath,\n    base,\n  );\n\n  // Both clients render from one template: they differ only in how they await,\n  // and keeping two copies is how a fix lands in one and not the other.\n  // `clientModuleName` names the emitted file, `isAsync` selects the keywords.\n  const clientDir = path.join(import.meta.dirname, 'files', 'client');\n\n  if (clientType === 'sync' || clientType === 'both') {\n    generateFiles(tree, clientDir, outputPath, {\n      ...base,\n      isAsync: false,\n      clientModuleName: 'client',\n    });\n  }\n  if (clientType === 'async' || clientType === 'both') {\n    generateFiles(tree, clientDir, outputPath, {\n      ...base,\n      isAsync: true,\n      clientModuleName: 'async_client',\n    });\n  }\n};\n\nexport default openApiPyClientGenerator;\n"],"names":["generateFiles","path","declareDependencies","formatFilesInSubtree","updateGitIgnore","addGeneratorMetricsIfApplicable","getGeneratorInfo","buildOpenApiCodeGenerationData","toPythonClassName","toPythonLiteral","isPythonCollection","needsPythonTypeAdapter","annotatePythonData","assertNoClashingPythonNames","OPEN_API_PY_CLIENT_GENERATOR_INFO","filename","OPEN_API_PY_CLIENT_DEPENDENCIES","py","name","openApiPyClientGenerator","tree","options","data","openApiSpecPath","clientType","model","models","generateOpenApiPyClient","outputPath","patterns","base","className","join","dirname","clientDir","isAsync","clientModuleName"],"mappings":"AAAA;;;CAGC,GACD,SAASA,aAAa,QAAmB,aAAa;AACtD,YAAYC,UAAU,OAAO;AAC7B,SAASC,mBAAmB,QAAQ,uCAAuC;AAC3E,SAASC,oBAAoB,QAAQ,wBAAwB;AAC7D,SAASC,eAAe,QAAQ,qBAAqB;AACrD,SAASC,+BAA+B,QAAQ,yBAAyB;AACzE,SAASC,gBAAgB,QAA8B,oBAAoB;AAC3E,SAASC,8BAA8B,QAAQ,4BAA4B;AAC3E,SACEC,iBAAiB,EACjBC,eAAe,QACV,qCAAqC;AAC5C,SAEEC,kBAAkB,EAClBC,sBAAsB,QACjB,iCAAiC;AACxC,SACEC,kBAAkB,EAClBC,2BAA2B,QACtB,2BAA2B;AAGlC,OAAO,MAAMC,oCACXR,iBAAiB,YAAYS,QAAQ,EAAE;AAEzC;;;;CAIC,GACD,OAAO,MAAMC,kCAAkCd,sBAAsB;IACnEe,IAAI;QAAC;YAAEC,MAAM;QAAQ;QAAG;YAAEA,MAAM;QAAW;KAAE;AAC/C,GAAG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BC,GACD,OAAO,MAAMC,2BAA2B,OACtCC,MACAC;IAEA,MAAMC,OAAO,MAAMf,+BACjBa,MACAC,QAAQE,eAAe;IAEzB,MAAMC,aAAaH,QAAQG,UAAU,IAAI;IAEzC,+EAA+E;IAC/E,gFAAgF;IAChFZ,mBAAmBU;IAEnB,KAAK,MAAMG,SAASH,KAAKI,MAAM,CAAE;QAC/Bb,4BAA4BY;IAC9B;IAEAE,wBAAwBP,MAAME,MAAMD,QAAQO,UAAU,EAAEJ;IAExD,wEAAwE;IACxE,2CAA2C;IAC3CpB,gBAAgBgB,MAAM,KAAK,CAACS,WAAa;eAAIA;YAAUR,QAAQO,UAAU;SAAC;IAE1E,MAAMvB,gCAAgCe,MAAM;QAC1CN;KACD;IAED,MAAMX,qBAAqBiB;AAC7B,EAAE;AAEF;;CAEC,GACD,OAAO,MAAMO,0BAA0B,CACrCP,MACAE,MACAM,YACAJ,aAAwC,MAAM;IAE9C,2EAA2E;IAC3E,4EAA4E;IAC5E,yEAAyE;IACzE,MAAMM,OAAO;QACX,GAAGR,IAAI;QACP,4EAA4E;QAC5E,0EAA0E;QAC1E,2EAA2E;QAC3E,2EAA2E;QAC3E,6DAA6D;QAC7DS,WAAWvB,kBAAkBc,KAAKS,SAAS;QAC3CP;QACAf;QACAC;QACAC;IACF;IAEAX,cACEoB,MACAnB,KAAK+B,IAAI,CAAC,YAAYC,OAAO,EAAE,SAAS,WACxCL,YACAE;IAGF,6EAA6E;IAC7E,sEAAsE;IACtE,6EAA6E;IAC7E,MAAMI,YAAYjC,KAAK+B,IAAI,CAAC,YAAYC,OAAO,EAAE,SAAS;IAE1D,IAAIT,eAAe,UAAUA,eAAe,QAAQ;QAClDxB,cAAcoB,MAAMc,WAAWN,YAAY;YACzC,GAAGE,IAAI;YACPK,SAAS;YACTC,kBAAkB;QACpB;IACF;IACA,IAAIZ,eAAe,WAAWA,eAAe,QAAQ;QACnDxB,cAAcoB,MAAMc,WAAWN,YAAY;YACzC,GAAGE,IAAI;YACPK,SAAS;YACTC,kBAAkB;QACpB;IACF;AACF,EAAE;AAEF,eAAejB,yBAAyB"}

package/src/open-api/py-client/schema.d.js

@@ -0,0 +1,6 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */ export { };
+
+//# sourceMappingURL=schema.d.js.map

package/src/open-api/py-client/schema.d.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../packages/nx-plugin/src/open-api/py-client/schema.d.ts"],"sourcesContent":["/**\n * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\n\nexport type OpenApiPyClientClientType = 'sync' | 'async' | 'both';\n\nexport interface OpenApiPyClientGeneratorSchema {\n  openApiSpecPath: string;\n  outputPath: string;\n  clientType?: OpenApiPyClientClientType;\n}\n"],"names":[],"mappings":"AAAA;;;CAGC,GAID,WAIC"}

package/src/open-api/py-client/schema.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export type OpenApiPyClientClientType = 'sync' | 'async' | 'both';
+
+export interface OpenApiPyClientGeneratorSchema {
+  openApiSpecPath: string;
+  outputPath: string;
+  clientType?: OpenApiPyClientClientType;
+}

package/src/open-api/py-client/schema.json

@@ -0,0 +1,28 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "OpenApiPyClient",
+  "title": "OpenAPI Python Client",
+  "description": "Generate a Python httpx client from an OpenAPI specification",
+  "type": "object",
+  "properties": {
+    "openApiSpecPath": {
+      "type": "string",
+      "description": "Path to the OpenAPI specification relative to the monorepo root",
+      "x-priority": "important"
+    },
+    "outputPath": {
+      "type": "string",
+      "description": "Path to the directory in which to generate the client relative to the monorepo root",
+      "x-priority": "important"
+    },
+    "clientType": {
+      "type": "string",
+      "description": "Which clients to emit. 'sync' emits client.py using httpx.Client, 'async' emits async_client.py using httpx.AsyncClient, 'both' emits both.",
+      "enum": ["sync", "async", "both"],
+      "x-prompt": "Which clients would you like to emit?",
+      "default": "both",
+      "x-priority": "important"
+    }
+  },
+  "required": ["openApiSpecPath", "outputPath"]
+}