@contractkit/plugin-python 0.9.1

package/dist/index.js

@@ -0,0 +1,1046 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/index.ts
+import { resolve, join } from "path";
+
+// src/codegen-models.ts
+import { computeModelsWithInput, topoSortModels, collectExternalRefs, collectExternalInputRefs } from "@contractkit/core";
+function generatePydanticModels(root, opts = {}) {
+  const externalRefs = collectExternalRefs(root);
+  const externalModelsWithInput = opts.modelsWithInput ?? /* @__PURE__ */ new Set();
+  const localModelsWithInput = computeModelsWithInput(root.models, externalModelsWithInput);
+  const allModelsWithInput = /* @__PURE__ */ new Set([
+    ...localModelsWithInput,
+    ...externalModelsWithInput
+  ]);
+  const externalInputRefs = allModelsWithInput.size > 0 ? collectExternalInputRefs(root, allModelsWithInput) : [];
+  const allExternalRefs = [
+    .../* @__PURE__ */ new Set([
+      ...externalRefs,
+      ...externalInputRefs
+    ])
+  ].sort();
+  const imports = new ImportTracker();
+  imports.add("pydantic", "BaseModel");
+  for (const model of root.models) {
+    if (model.type) {
+      scanTypeImports(model.type, imports);
+    } else {
+      for (const f of model.fields) {
+        scanTypeImports(f.type, imports);
+      }
+    }
+  }
+  const lines = [];
+  lines.push("# Auto-generated by contractkit-plugin-python-sdk. Do not edit manually.");
+  lines.push("from __future__ import annotations");
+  const crossFileImports = [];
+  for (const ref of allExternalRefs) {
+    const modulePath = opts.modelModulePaths?.get(ref);
+    if (modulePath && modulePath !== opts.currentModule) {
+      crossFileImports.push(`from ${modulePath} import ${ref}`);
+    }
+  }
+  const modelLines = [];
+  for (const model of topoSortModels(root.models)) {
+    modelLines.push("");
+    modelLines.push(...generateModel(model, allModelsWithInput, imports));
+  }
+  const stdlibLines = imports.render();
+  lines.push(...stdlibLines);
+  if (crossFileImports.length > 0) {
+    lines.push("");
+    lines.push(...crossFileImports);
+  }
+  lines.push(...modelLines);
+  lines.push("");
+  return lines.join("\n");
+}
+__name(generatePydanticModels, "generatePydanticModels");
+var ImportTracker = class ImportTracker2 {
+  static {
+    __name(this, "ImportTracker");
+  }
+  groups = /* @__PURE__ */ new Map();
+  add(module, name) {
+    let s = this.groups.get(module);
+    if (!s) {
+      s = /* @__PURE__ */ new Set();
+      this.groups.set(module, s);
+    }
+    s.add(name);
+  }
+  has(module, name) {
+    return this.groups.get(module)?.has(name) ?? false;
+  }
+  render() {
+    const ORDER = [
+      "__future__",
+      "datetime",
+      "uuid",
+      "typing",
+      "pydantic"
+    ];
+    const lines = [];
+    lines.push("");
+    for (const mod of ORDER) {
+      const names = this.groups.get(mod);
+      if (!names || names.size === 0) continue;
+      const sorted = [
+        ...names
+      ].sort().join(", ");
+      lines.push(`from ${mod} import ${sorted}`);
+    }
+    for (const [mod, names] of this.groups) {
+      if (ORDER.includes(mod)) continue;
+      const sorted = [
+        ...names
+      ].sort().join(", ");
+      lines.push(`from ${mod} import ${sorted}`);
+    }
+    return lines;
+  }
+};
+function scanTypeImports(type, imports) {
+  switch (type.kind) {
+    case "scalar":
+      switch (type.name) {
+        case "date":
+          imports.add("datetime", "date");
+          break;
+        case "time":
+          imports.add("datetime", "time");
+          break;
+        case "datetime":
+          imports.add("datetime", "datetime");
+          break;
+        case "duration":
+          imports.add("datetime", "timedelta");
+          break;
+        case "uuid":
+          imports.add("uuid", "UUID");
+          break;
+        case "unknown":
+        case "json":
+        case "object":
+          imports.add("typing", "Any");
+          break;
+      }
+      break;
+    case "enum":
+      imports.add("typing", "Literal");
+      break;
+    case "union":
+      type.members.forEach((m) => scanTypeImports(m, imports));
+      break;
+    case "discriminatedUnion":
+      imports.add("typing", "Annotated");
+      imports.add("pydantic", "Field");
+      type.members.forEach((m) => scanTypeImports(m, imports));
+      break;
+    case "intersection":
+      imports.add("typing", "Any");
+      break;
+    case "array":
+      scanTypeImports(type.item, imports);
+      break;
+    case "tuple":
+      type.items.forEach((t) => scanTypeImports(t, imports));
+      break;
+    case "record":
+      scanTypeImports(type.key, imports);
+      scanTypeImports(type.value, imports);
+      break;
+    case "lazy":
+      scanTypeImports(type.inner, imports);
+      break;
+    case "inlineObject":
+      imports.add("typing", "Any");
+      break;
+  }
+}
+__name(scanTypeImports, "scanTypeImports");
+function renderPyType(type, modelsWithInput, forInput = false) {
+  switch (type.kind) {
+    case "scalar":
+      return renderScalar(type.name);
+    case "enum":
+      return `Literal[${type.values.map((v) => JSON.stringify(v)).join(", ")}]`;
+    case "literal":
+      return typeof type.value === "string" ? JSON.stringify(type.value) : String(type.value);
+    case "array":
+      return `list[${renderPyType(type.item, modelsWithInput, forInput)}]`;
+    case "tuple":
+      if (type.items.length === 0) return "tuple[()]";
+      return `tuple[${type.items.map((t) => renderPyType(t, modelsWithInput, forInput)).join(", ")}]`;
+    case "record":
+      return `dict[${renderPyType(type.key, modelsWithInput, forInput)}, ${renderPyType(type.value, modelsWithInput, forInput)}]`;
+    case "union":
+      return type.members.map((m) => renderPyType(m, modelsWithInput, forInput)).join(" | ");
+    case "discriminatedUnion": {
+      const inner = type.members.map((m) => renderPyType(m, modelsWithInput, forInput)).join(" | ");
+      return `Annotated[${inner}, Field(discriminator=${JSON.stringify(type.discriminator)})]`;
+    }
+    case "intersection":
+      return "dict[str, Any]";
+    case "ref": {
+      if (forInput && modelsWithInput?.has(type.name)) {
+        return `${type.name}Input`;
+      }
+      return type.name;
+    }
+    case "inlineObject":
+      return "dict[str, Any]";
+    case "lazy":
+      return renderPyType(type.inner, modelsWithInput, forInput);
+  }
+}
+__name(renderPyType, "renderPyType");
+function renderScalar(name) {
+  switch (name) {
+    case "string":
+    case "email":
+    case "url":
+      return "str";
+    case "number":
+      return "float";
+    case "int":
+      return "int";
+    case "bigint":
+      return "int";
+    case "boolean":
+      return "bool";
+    case "date":
+      return "date";
+    case "time":
+      return "time";
+    case "datetime":
+      return "datetime";
+    case "duration":
+      return "timedelta";
+    case "uuid":
+      return "UUID";
+    case "null":
+      return "None";
+    case "binary":
+      return "bytes";
+    case "unknown":
+    case "json":
+    case "object":
+      return "Any";
+    default:
+      return "Any";
+  }
+}
+__name(renderScalar, "renderScalar");
+function toPythonFieldName(name) {
+  let result = name.replace(/[^a-zA-Z0-9_]/g, "_");
+  result = result.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+  result = result.replace(/_+/g, "_").replace(/^_|_$/g, "");
+  if (/^\d/.test(result)) result = "f_" + result;
+  return result;
+}
+__name(toPythonFieldName, "toPythonFieldName");
+function generateModel(model, allModelsWithInput, imports) {
+  if (model.type) {
+    return generateTypeAlias(model, allModelsWithInput, imports);
+  }
+  const needsInputSplit = model.fields.some((f) => f.visibility !== "normal") || allModelsWithInput.has(model.name);
+  if (needsInputSplit) {
+    return generateSplitModel(model, allModelsWithInput, imports);
+  }
+  return generateSimpleModel(model, allModelsWithInput, imports);
+}
+__name(generateModel, "generateModel");
+function generateTypeAlias(model, allModelsWithInput, _) {
+  const lines = [];
+  if (model.description) lines.push(`# ${model.description}`);
+  if (model.deprecated) lines.push("# @deprecated");
+  lines.push(`${model.name} = ${renderPyType(model.type, allModelsWithInput)}`);
+  if (allModelsWithInput.has(model.name)) {
+    lines.push(`${model.name}Input = ${renderPyType(model.type, allModelsWithInput, true)}`);
+  }
+  return lines;
+}
+__name(generateTypeAlias, "generateTypeAlias");
+function generateSimpleModel(model, allModelsWithInput, imports) {
+  const lines = [];
+  if (model.description) lines.push(`# ${model.description}`);
+  if (model.deprecated) lines.push("# @deprecated");
+  const baseList = model.bases && model.bases.length > 0 ? model.bases.join(", ") : "BaseModel";
+  lines.push(`class ${model.name}(${baseList}):`);
+  const fieldLines = renderFields(model.fields, allModelsWithInput, imports, false);
+  const needsConfig = model.fields.some((f) => toPythonFieldName(f.name) !== f.name);
+  if (needsConfig) {
+    imports.add("pydantic", "ConfigDict");
+    lines.push(`    model_config = ConfigDict(populate_by_name=True)`);
+    lines.push("");
+  }
+  if (fieldLines.length === 0) {
+    lines.push("    pass");
+  } else {
+    lines.push(...fieldLines);
+  }
+  return lines;
+}
+__name(generateSimpleModel, "generateSimpleModel");
+function generateSplitModel(model, allModelsWithInput, imports) {
+  const lines = [];
+  const readFields = model.fields.filter((f) => f.visibility !== "writeonly");
+  if (model.description) lines.push(`# ${model.description}`);
+  if (model.deprecated) lines.push("# @deprecated");
+  const readBaseList = model.bases && model.bases.length > 0 ? model.bases.join(", ") : "BaseModel";
+  lines.push(`class ${model.name}(${readBaseList}):`);
+  const readNeedsConfig = readFields.some((f) => toPythonFieldName(f.name) !== f.name);
+  if (readNeedsConfig) {
+    imports.add("pydantic", "ConfigDict");
+    lines.push(`    model_config = ConfigDict(populate_by_name=True)`);
+    lines.push("");
+  }
+  const readFieldLines = renderFields(readFields, allModelsWithInput, imports, false);
+  if (readFieldLines.length === 0) {
+    lines.push("    pass");
+  } else {
+    lines.push(...readFieldLines);
+  }
+  lines.push("");
+  const writeFields = model.fields.filter((f) => f.visibility !== "readonly");
+  const inputBaseList = model.bases && model.bases.length > 0 ? model.bases.map((b) => allModelsWithInput.has(b) ? `${b}Input` : b).join(", ") : "BaseModel";
+  lines.push(`class ${model.name}Input(${inputBaseList}):`);
+  const writeNeedsConfig = writeFields.some((f) => toPythonFieldName(f.name) !== f.name);
+  if (writeNeedsConfig) {
+    imports.add("pydantic", "ConfigDict");
+    lines.push(`    model_config = ConfigDict(populate_by_name=True)`);
+    lines.push("");
+  }
+  const writeFieldLines = renderFields(writeFields, allModelsWithInput, imports, true);
+  if (writeFieldLines.length === 0) {
+    lines.push("    pass");
+  } else {
+    lines.push(...writeFieldLines);
+  }
+  return lines;
+}
+__name(generateSplitModel, "generateSplitModel");
+function renderFields(fields, allModelsWithInput, imports, forInput) {
+  const lines = [];
+  for (const f of fields) {
+    lines.push(...renderField(f, allModelsWithInput, imports, forInput));
+  }
+  return lines;
+}
+__name(renderFields, "renderFields");
+function renderField(field, allModelsWithInput, imports, forInput) {
+  const lines = [];
+  const pyName = toPythonFieldName(field.name);
+  const needsAlias = pyName !== field.name;
+  let typeStr = renderPyType(field.type, allModelsWithInput, forInput);
+  if (field.nullable) typeStr = `${typeStr} | None`;
+  const isOptional = field.optional || field.default !== void 0;
+  const fieldAnnotations = [];
+  if (needsAlias) {
+    imports.add("pydantic", "Field");
+    fieldAnnotations.push(`alias=${JSON.stringify(field.name)}`);
+  }
+  if (field.default !== void 0) {
+    const def = typeof field.default === "string" ? JSON.stringify(field.default) : String(field.default);
+    fieldAnnotations.push(`default=${def}`);
+  }
+  if (field.deprecated) lines.push(`    # @deprecated`);
+  if (field.description) lines.push(`    # ${field.description}`);
+  let rhs;
+  if (fieldAnnotations.length > 0) {
+    imports.add("pydantic", "Field");
+    rhs = `Field(${fieldAnnotations.join(", ")})`;
+  } else if (isOptional) {
+    rhs = "None";
+  } else {
+    rhs = "";
+  }
+  const optSuffix = isOptional && !field.nullable ? ` | None` : "";
+  const fullType = typeStr + optSuffix;
+  if (rhs) {
+    lines.push(`    ${pyName}: ${fullType} = ${rhs}`);
+  } else {
+    lines.push(`    ${pyName}: ${fullType}`);
+  }
+  return lines;
+}
+__name(renderField, "renderField");
+function deriveModelsModuleName(file) {
+  const base = file.split("/").pop()?.replace(/\.(op\.)?ck$/, "") ?? "models";
+  const clean = base.replace(/[^a-zA-Z0-9]/g, "_").toLowerCase();
+  return `_models_${clean}`;
+}
+__name(deriveModelsModuleName, "deriveModelsModuleName");
+
+// src/codegen-client.ts
+import { resolveModifiers, classifyContentType } from "@contractkit/core";
+function hasPublicOperations(root, includeInternal = false) {
+  for (const route of root.routes) {
+    for (const op of route.operations) {
+      if (includeInternal || !resolveModifiers(route, op).includes("internal")) return true;
+    }
+  }
+  return false;
+}
+__name(hasPublicOperations, "hasPublicOperations");
+function generatePythonClient(root, opts = {}) {
+  const clientClassName = deriveClientClassName(root.file);
+  const { modelsWithInput } = opts;
+  const includeInternal = opts.includeInternal ?? false;
+  const referencedModels = collectReferencedModels(root, modelsWithInput, includeInternal);
+  const lines = [];
+  lines.push("# Auto-generated by contractkit-plugin-python-sdk. Do not edit manually.");
+  lines.push("from __future__ import annotations");
+  lines.push("");
+  const needsDatetime = referencedModels.has("__datetime__");
+  const needsDate = referencedModels.has("__date__");
+  const needsTime = referencedModels.has("__time__");
+  const needsUUID = referencedModels.has("__uuid__");
+  const needsAny = referencedModels.has("__any__");
+  if (needsDatetime || needsDate || needsTime) {
+    const dtParts = [];
+    if (needsDate) dtParts.push("date");
+    if (needsDatetime) dtParts.push("datetime");
+    if (needsTime) dtParts.push("time");
+    lines.push(`from datetime import ${dtParts.join(", ")}`);
+  }
+  if (needsUUID) lines.push("from uuid import UUID");
+  const publicOps = [];
+  for (const route of root.routes) {
+    for (const op of route.operations) {
+      if (!includeInternal && resolveModifiers(route, op).includes("internal")) continue;
+      publicOps.push({
+        route,
+        op
+      });
+    }
+  }
+  const opsWithRespHeaders = publicOps.filter(({ op }) => {
+    const primary = op.responses.find((r) => r.bodyType) ?? op.responses[0];
+    return (primary?.headers?.length ?? 0) > 0;
+  });
+  if (needsAny || opsWithRespHeaders.length > 0) {
+    const typingImports = [];
+    if (needsAny) typingImports.push("Any");
+    if (opsWithRespHeaders.length > 0) typingImports.push("TypedDict");
+    lines.push(`from typing import ${typingImports.join(", ")}`);
+  }
+  lines.push("from ._base_client import BaseClient, SdkError  # noqa: F401");
+  const modelImportsByModule = /* @__PURE__ */ new Map();
+  for (const name of referencedModels) {
+    if (name.startsWith("__")) continue;
+    const modulePath = opts.modelModulePaths?.get(name);
+    if (modulePath) {
+      let s = modelImportsByModule.get(modulePath);
+      if (!s) {
+        s = /* @__PURE__ */ new Set();
+        modelImportsByModule.set(modulePath, s);
+      }
+      s.add(name);
+    }
+  }
+  for (const [mod, names] of [
+    ...modelImportsByModule
+  ].sort((a, b) => a[0].localeCompare(b[0]))) {
+    const sorted = [
+      ...names
+    ].sort().join(", ");
+    lines.push(`from ${mod} import ${sorted}`);
+  }
+  for (const { route, op } of opsWithRespHeaders) {
+    const primary = op.responses.find((r) => r.bodyType) ?? op.responses[0];
+    const className = `${snakeToPascal(deriveMethodName(op, route))}Headers`;
+    lines.push("");
+    lines.push("");
+    lines.push(`class ${className}(TypedDict, total=False):`);
+    for (const h of primary.headers) {
+      const pyName = toPythonFieldName(h.name);
+      const tag = h.optional ? "optional" : "required";
+      lines.push(`    ${pyName}: str  # ${h.name} (${tag})`);
+    }
+  }
+  lines.push("");
+  lines.push("");
+  lines.push(`class ${clientClassName}(BaseClient):`);
+  let hasAnyMethod = false;
+  for (const route of root.routes) {
+    for (const op of route.operations) {
+      const mods = resolveModifiers(route, op);
+      if (!includeInternal && mods.includes("internal")) continue;
+      hasAnyMethod = true;
+      lines.push("");
+      if (mods.includes("deprecated")) lines.push("    # @deprecated");
+      lines.push(...generateMethod(route, op, opts));
+    }
+  }
+  if (!hasAnyMethod) {
+    lines.push("    pass");
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+__name(generatePythonClient, "generatePythonClient");
+function generateMethod(route, op, opts) {
+  const lines = [];
+  const { modelsWithInput } = opts;
+  const methodName = deriveMethodName(op, route);
+  const httpMethod = op.method.toUpperCase();
+  const params = buildMethodParams(route, op, modelsWithInput);
+  const selfParam = "self";
+  const allParams = params.map((p) => {
+    if (p.optional) return `${p.name}: ${p.type} | None = None`;
+    return `${p.name}: ${p.type}`;
+  });
+  const paramStr = allParams.length > 0 ? `, ${allParams.join(", ")}` : "";
+  const primaryResponse = op.responses.find((r) => r.bodyType) ?? op.responses[0];
+  const isVoid = !primaryResponse?.bodyType;
+  const respCategory = primaryResponse?.contentType ? classifyContentType(primaryResponse.contentType) : "json";
+  const dataType = isVoid ? "None" : respCategory === "text" ? "str" : respCategory === "binary" ? "bytes" : renderPyType(primaryResponse.bodyType, modelsWithInput);
+  const isModelReturn = !isVoid && respCategory === "json" && isModelRef(primaryResponse.bodyType, modelsWithInput);
+  const isListModelReturn = !isVoid && respCategory === "json" && isListModelRef(primaryResponse.bodyType, modelsWithInput);
+  const respHeaders = primaryResponse?.headers ?? [];
+  const hasRespHeaders = respHeaders.length > 0;
+  const headersTypeName = hasRespHeaders ? `${snakeToPascal(methodName)}Headers` : "";
+  const returnType = hasRespHeaders ? isVoid ? headersTypeName : `tuple[${dataType}, ${headersTypeName}]` : dataType;
+  const desc = op.description ?? route.description;
+  if (op.name || desc) {
+    lines.push(`    async def ${methodName}(${selfParam}${paramStr}) -> ${returnType}:`);
+    lines.push(`        """`);
+    if (op.name) lines.push(`        ${op.name}`);
+    if (desc) lines.push(`        ${desc}`);
+    lines.push(`        """`);
+  } else {
+    lines.push(`    async def ${methodName}(${selfParam}${paramStr}) -> ${returnType}:`);
+  }
+  const urlExpr = buildUrlExpression(route.path);
+  const hasQuery = !!op.query;
+  const primaryBody = op.request?.bodies[0];
+  const hasBody = !!primaryBody;
+  const isMultipart = primaryBody?.contentType === "multipart/form-data";
+  const hasCustomHeaders = !!op.headers;
+  const fetchKwargs = [];
+  fetchKwargs.push(`method="${httpMethod}"`);
+  const reqCategory = primaryBody?.contentType ? classifyContentType(primaryBody.contentType) : "json";
+  if (hasBody) {
+    const bodyParam = params.find((p) => p.name === "body");
+    if (isMultipart) {
+      fetchKwargs.push("body=body");
+    } else if (reqCategory === "text" || reqCategory === "binary") {
+      fetchKwargs.push("body=body");
+    } else if (bodyParam?.isModel) {
+      fetchKwargs.push('body=body.model_dump(mode="json")');
+    } else {
+      fetchKwargs.push("body=body");
+    }
+    if (primaryBody.contentType !== "application/json") {
+      fetchKwargs.push(`content_type=${JSON.stringify(primaryBody.contentType)}`);
+    }
+    if (reqCategory === "text" || reqCategory === "binary") {
+      fetchKwargs.push(`body_kind="${reqCategory}"`);
+    }
+  }
+  if (respCategory === "text" || respCategory === "binary") {
+    fetchKwargs.push(`response_kind="${respCategory}"`);
+  }
+  if (hasQuery) {
+    fetchKwargs.push("params=query");
+  }
+  if (hasCustomHeaders) {
+    fetchKwargs.push("extra_headers=custom_headers");
+  }
+  const kwargsStr = fetchKwargs.length > 1 ? fetchKwargs.join(", ") : fetchKwargs[0] ?? "";
+  if (hasRespHeaders) {
+    lines.push(`        result, _response_headers = await self._fetch_with_headers(${urlExpr}, ${kwargsStr})`);
+    lines.push(...buildHeadersDictLines(respHeaders, headersTypeName));
+  } else {
+    lines.push(`        result = await self._fetch(${urlExpr}, ${kwargsStr})`);
+  }
+  if (isVoid) {
+    if (hasRespHeaders) {
+      lines.push(`        return headers`);
+    } else {
+      lines.push(`        return None`);
+    }
+  } else {
+    let dataExpr;
+    if (isListModelReturn) {
+      const innerType = getListItemType(primaryResponse.bodyType, modelsWithInput);
+      dataExpr = `[${innerType}.model_validate(item) for item in result]`;
+    } else if (isModelReturn) {
+      dataExpr = `${dataType}.model_validate(result)`;
+    } else {
+      dataExpr = "result";
+    }
+    if (hasRespHeaders) {
+      lines.push(`        return ${dataExpr}, headers`);
+    } else {
+      lines.push(`        return ${dataExpr}`);
+    }
+  }
+  return lines;
+}
+__name(generateMethod, "generateMethod");
+function buildHeadersDictLines(headers, typeName) {
+  const lines = [];
+  lines.push(`        headers: ${typeName} = {}`);
+  for (const h of headers) {
+    const pyName = toPythonFieldName(h.name);
+    lines.push(`        if ${JSON.stringify(h.name.toLowerCase())} in _response_headers:`);
+    lines.push(`            headers[${JSON.stringify(pyName)}] = _response_headers[${JSON.stringify(h.name.toLowerCase())}]`);
+  }
+  return lines;
+}
+__name(buildHeadersDictLines, "buildHeadersDictLines");
+function snakeToPascal(s) {
+  return s.split("_").filter(Boolean).map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("");
+}
+__name(snakeToPascal, "snakeToPascal");
+function buildUrlExpression(path) {
+  const hasBraces = /\{[a-zA-Z_][a-zA-Z0-9_]*\}/.test(path);
+  if (!hasBraces) return `"${path}"`;
+  const interpolated = path.replace(/\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g, (_m, name) => `{${name}}`);
+  return `f"${interpolated}"`;
+}
+__name(buildUrlExpression, "buildUrlExpression");
+function buildMethodParams(route, op, modelsWithInput) {
+  const params = [];
+  if (route.params) {
+    if (route.params.kind === "params") {
+      for (const p of route.params.nodes) {
+        params.push({
+          name: toPythonFieldName(p.name),
+          type: renderPyType(p.type, modelsWithInput),
+          optional: false,
+          isModel: false
+        });
+      }
+    } else if (route.params.kind === "ref") {
+      const typeName = modelsWithInput?.has(route.params.name) ? `${route.params.name}Input` : route.params.name;
+      params.push({
+        name: "params",
+        type: typeName,
+        optional: false,
+        isModel: true
+      });
+    } else {
+      params.push({
+        name: "params",
+        type: renderPyType(route.params.node, modelsWithInput),
+        optional: false,
+        isModel: false
+      });
+    }
+  }
+  const primaryBody = op.request?.bodies[0];
+  if (primaryBody) {
+    const cat = classifyContentType(primaryBody.contentType);
+    if (cat === "multipart" || cat === "binary") {
+      params.push({
+        name: "body",
+        type: "bytes",
+        optional: false,
+        isModel: false
+      });
+    } else if (cat === "text") {
+      params.push({
+        name: "body",
+        type: "str",
+        optional: false,
+        isModel: false
+      });
+    } else {
+      const bodyType = renderInputPyType(primaryBody.bodyType, modelsWithInput);
+      const isModel = isModelRef(primaryBody.bodyType, modelsWithInput);
+      params.push({
+        name: "body",
+        type: bodyType,
+        optional: false,
+        isModel
+      });
+    }
+  }
+  if (op.query) {
+    const queryType = renderParamSourceType(op.query, modelsWithInput, true);
+    params.push({
+      name: "query",
+      type: queryType,
+      optional: true,
+      isModel: false
+    });
+  }
+  if (op.headers) {
+    const headersType = renderParamSourceType(op.headers, modelsWithInput, true);
+    params.push({
+      name: "custom_headers",
+      type: headersType,
+      optional: true,
+      isModel: false
+    });
+  }
+  return params;
+}
+__name(buildMethodParams, "buildMethodParams");
+function renderParamSourceType(source, modelsWithInput, forInput = false) {
+  if (source.kind === "ref") {
+    const typeName = forInput && modelsWithInput?.has(source.name) ? `${source.name}Input` : source.name;
+    return typeName;
+  }
+  if (source.kind === "params") {
+    return `dict`;
+  }
+  return renderPyType(source.node, modelsWithInput, forInput);
+}
+__name(renderParamSourceType, "renderParamSourceType");
+function renderInputPyType(type, modelsWithInput) {
+  return renderPyType(type, modelsWithInput, true);
+}
+__name(renderInputPyType, "renderInputPyType");
+function isModelRef(type, modelsWithInput) {
+  if (type.kind === "ref") return /^[A-Z]/.test(type.name);
+  if (type.kind === "lazy") return isModelRef(type.inner, modelsWithInput);
+  return false;
+}
+__name(isModelRef, "isModelRef");
+function isListModelRef(type, modelsWithInput) {
+  if (type.kind === "array") return isModelRef(type.item, modelsWithInput);
+  if (type.kind === "lazy") return isListModelRef(type.inner, modelsWithInput);
+  return false;
+}
+__name(isListModelRef, "isListModelRef");
+function getListItemType(type, modelsWithInput) {
+  if (type.kind === "array") return renderPyType(type.item, modelsWithInput);
+  return "dict";
+}
+__name(getListItemType, "getListItemType");
+function collectReferencedModels(root, modelsWithInput, includeInternal = false) {
+  const refs = /* @__PURE__ */ new Set();
+  for (const route of root.routes) {
+    for (const op of route.operations) {
+      if (!includeInternal && resolveModifiers(route, op).includes("internal")) continue;
+      if (route.params) collectParamSourceRefs(route.params, refs, modelsWithInput);
+      if (op.request) {
+        for (const body of op.request.bodies) collectTypeRefs(body.bodyType, refs, modelsWithInput, true);
+      }
+      for (const resp of op.responses) {
+        if (resp.bodyType) collectTypeRefs(resp.bodyType, refs, modelsWithInput, false);
+      }
+      if (op.query) collectParamSourceRefs(op.query, refs, modelsWithInput);
+      if (op.headers) collectParamSourceRefs(op.headers, refs, modelsWithInput);
+    }
+  }
+  return refs;
+}
+__name(collectReferencedModels, "collectReferencedModels");
+function collectParamSourceRefs(source, out, modelsWithInput) {
+  if (source.kind === "ref") {
+    addModelRef(source.name, out, modelsWithInput);
+  } else if (source.kind === "params") {
+    for (const p of source.nodes) collectTypeRefs(p.type, out, modelsWithInput);
+  } else {
+    collectTypeRefs(source.node, out, modelsWithInput);
+  }
+}
+__name(collectParamSourceRefs, "collectParamSourceRefs");
+function addModelRef(name, out, modelsWithInput) {
+  if (/^[A-Z]/.test(name)) {
+    out.add(name);
+    if (modelsWithInput?.has(name)) out.add(`${name}Input`);
+  }
+}
+__name(addModelRef, "addModelRef");
+function collectTypeRefs(type, out, modelsWithInput, forInput = false) {
+  switch (type.kind) {
+    case "scalar":
+      switch (type.name) {
+        case "date":
+          out.add("__date__");
+          break;
+        case "time":
+          out.add("__time__");
+          break;
+        case "datetime":
+          out.add("__datetime__");
+          break;
+        case "uuid":
+          out.add("__uuid__");
+          break;
+        case "unknown":
+        case "json":
+        case "object":
+          out.add("__any__");
+          break;
+      }
+      break;
+    case "ref":
+      if (forInput && modelsWithInput?.has(type.name)) {
+        out.add(`${type.name}Input`);
+      } else {
+        addModelRef(type.name, out, modelsWithInput);
+      }
+      break;
+    case "array":
+      collectTypeRefs(type.item, out, modelsWithInput, forInput);
+      break;
+    case "tuple":
+      type.items.forEach((t) => collectTypeRefs(t, out, modelsWithInput, forInput));
+      break;
+    case "record":
+      collectTypeRefs(type.key, out, modelsWithInput, forInput);
+      collectTypeRefs(type.value, out, modelsWithInput, forInput);
+      break;
+    case "union":
+      type.members.forEach((m) => collectTypeRefs(m, out, modelsWithInput, forInput));
+      break;
+    case "discriminatedUnion":
+      type.members.forEach((m) => collectTypeRefs(m, out, modelsWithInput, forInput));
+      break;
+    case "intersection":
+      out.add("__any__");
+      break;
+    case "lazy":
+      collectTypeRefs(type.inner, out, modelsWithInput, forInput);
+      break;
+    case "inlineObject":
+      out.add("__any__");
+      break;
+  }
+}
+__name(collectTypeRefs, "collectTypeRefs");
+function deriveBaseName(file) {
+  const base = file.split("/").pop()?.replace(/\.(op\.)?ck$/, "") ?? "Resource";
+  return base.split(".").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
+}
+__name(deriveBaseName, "deriveBaseName");
+function deriveClientClassName(file) {
+  return `${deriveBaseName(file)}Client`;
+}
+__name(deriveClientClassName, "deriveClientClassName");
+function deriveClientModuleName(file) {
+  const base = file.split("/").pop()?.replace(/\.(op\.)?ck$/, "") ?? "client";
+  const clean = base.replace(/[^a-zA-Z0-9]/g, "_").toLowerCase();
+  return `_client_${clean}`;
+}
+__name(deriveClientModuleName, "deriveClientModuleName");
+function deriveClientPropertyName(file) {
+  const base = deriveBaseName(file);
+  return base.charAt(0).toLowerCase() + base.slice(1);
+}
+__name(deriveClientPropertyName, "deriveClientPropertyName");
+function deriveMethodName(op, route) {
+  if (op.sdk) return toSnakeCase(op.sdk);
+  if (op.name) return toSnakeCase(op.name);
+  return inferMethodName(op.method, route.path);
+}
+__name(deriveMethodName, "deriveMethodName");
+function inferMethodName(method, path) {
+  const segments = path.split("/").filter((s) => s.length > 0);
+  const parts = [
+    method.toLowerCase()
+  ];
+  for (const seg of segments) {
+    if (seg.startsWith("{")) {
+      const paramName = seg.slice(1, -1);
+      parts.push("by_" + toSnakeCase(paramName));
+    } else {
+      parts.push(toSnakeCase(seg.replace(/[.-]/g, "_")));
+    }
+  }
+  return parts.join("_").replace(/_+/g, "_");
+}
+__name(inferMethodName, "inferMethodName");
+function toSnakeCase(s) {
+  return s.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^a-zA-Z0-9]/g, "_").toLowerCase().replace(/_+/g, "_").replace(/^_|_$/g, "");
+}
+__name(toSnakeCase, "toSnakeCase");
+var BASE_CLIENT_PY = `# Auto-generated by contractkit-plugin-python-sdk. Do not edit manually.
+from __future__ import annotations
+
+import httpx
+from typing import Any
+
+
+class SdkError(Exception):
+    def __init__(self, status: int, status_text: str, body: Any):
+        super().__init__(f"{status} {status_text}")
+        self.status = status
+        self.status_text = status_text
+        self.body = body
+
+
+class BaseClient:
+    def __init__(self, base_url: str, headers: dict[str, str] | None = None):
+        self._base_url = base_url.rstrip("/")
+        self._headers = headers or {}
+        self._http = httpx.AsyncClient()
+
+    async def _fetch(
+        self,
+        path: str,
+        *,
+        method: str,
+        body: Any = None,
+        params: dict | None = None,
+        extra_headers: dict | None = None,
+        content_type: str | None = None,
+        body_kind: str = "json",
+        response_kind: str = "json",
+    ) -> Any:
+        result, _ = await self._fetch_with_headers(
+            path,
+            method=method,
+            body=body,
+            params=params,
+            extra_headers=extra_headers,
+            content_type=content_type,
+            body_kind=body_kind,
+            response_kind=response_kind,
+        )
+        return result
+
+    async def _fetch_with_headers(
+        self,
+        path: str,
+        *,
+        method: str,
+        body: Any = None,
+        params: dict | None = None,
+        extra_headers: dict | None = None,
+        content_type: str | None = None,
+        body_kind: str = "json",
+        response_kind: str = "json",
+    ) -> tuple[Any, dict[str, str]]:
+        headers = {**self._headers, **(extra_headers or {})}
+        if body is not None:
+            headers["Content-Type"] = content_type or "application/json"
+        # body_kind controls how httpx serializes the request body:
+        #   "json"   \u2014 body is a JSON-serializable object, sent via httpx's json= kwarg
+        #   "text"/"binary" \u2014 body is a raw str/bytes payload, sent via content= unchanged
+        request_kwargs: dict[str, Any] = {"method": method, "url": f"{self._base_url}{path}", "params": params, "headers": headers}
+        if body is not None:
+            if body_kind == "json":
+                request_kwargs["json"] = body
+            else:
+                request_kwargs["content"] = body
+        response = await self._http.request(**request_kwargs)
+        if not response.is_success:
+            try:
+                error_body = response.json()
+            except Exception:
+                error_body = response.text
+            raise SdkError(response.status_code, response.reason_phrase, error_body)
+        # HTTP headers are case-insensitive \u2014 normalize to lowercase keys for stable lookup.
+        response_headers = {k.lower(): v for k, v in response.headers.items()}
+        if response.status_code == 204 or not response.content:
+            return None, response_headers
+        if response_kind == "text":
+            return response.text, response_headers
+        if response_kind == "binary":
+            return response.content, response_headers
+        return response.json(), response_headers
+`;
+
+// src/index.ts
+var plugin = {
+  name: "python-sdk",
+  cacheKey: "python-sdk",
+  async generateTargets(inputs, ctx) {
+    const config = ctx.options;
+    return createPythonSdkPlugin(config, ctx.rootDir).generateTargets(inputs, ctx);
+  }
+};
+var index_default = plugin;
+function createPythonSdkPlugin(config, rootDir) {
+  return {
+    name: "python-sdk",
+    cacheKey: `python-sdk:${JSON.stringify(config)}`,
+    async generateTargets({ contractRoots, opRoots, modelsWithInput: _modelsWithInput }, ctx) {
+      const modelsWithInput = _modelsWithInput;
+      const outDir = resolve(rootDir, config.baseDir ?? "python-sdk");
+      const modelModulePaths = /* @__PURE__ */ new Map();
+      const contractEntries = [];
+      for (const contractRoot of contractRoots) {
+        const moduleName = deriveModelsModuleName(contractRoot.file);
+        const outPath = join(outDir, `${moduleName}.py`);
+        contractEntries.push({
+          moduleName,
+          outPath,
+          root: contractRoot
+        });
+        for (const model of contractRoot.models) {
+          modelModulePaths.set(model.name, `.${moduleName}`);
+          if (modelsWithInput.has(model.name)) {
+            modelModulePaths.set(`${model.name}Input`, `.${moduleName}`);
+          }
+        }
+      }
+      for (const { moduleName, outPath, root } of contractEntries) {
+        const content = generatePydanticModels(root, {
+          modelModulePaths,
+          currentModule: `.${moduleName}`,
+          modelsWithInput
+        });
+        ctx.emitFile(outPath, content);
+      }
+      const clientInfos = [];
+      for (const opRoot of opRoots) {
+        if (!hasPublicOperations(opRoot, config.includeInternal)) continue;
+        const moduleName = deriveClientModuleName(opRoot.file);
+        const outPath = join(outDir, `${moduleName}.py`);
+        clientInfos.push({
+          moduleName,
+          className: deriveClientClassName(opRoot.file),
+          propertyName: deriveClientPropertyName(opRoot.file)
+        });
+        ctx.emitFile(outPath, generatePythonClient(opRoot, {
+          modelModulePaths,
+          currentModule: `.${moduleName}`,
+          modelsWithInput,
+          includeInternal: config.includeInternal
+        }));
+      }
+      ctx.emitFile(join(outDir, "_base_client.py"), BASE_CLIENT_PY);
+      ctx.emitFile(join(outDir, "requirements.txt"), "httpx\npydantic>=2.0\n");
+      const sdkClassName = config.packageName ? config.packageName.split(/[-._\s]+/).map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("") + "Sdk" : "Sdk";
+      const initLines = [
+        "# Auto-generated by contractkit-plugin-python-sdk. Do not edit manually.",
+        "from ._base_client import BaseClient, SdkError"
+      ];
+      for (const c of clientInfos) {
+        initLines.push(`from .${c.moduleName} import ${c.className}`);
+      }
+      initLines.push("");
+      initLines.push("");
+      if (clientInfos.length > 0) {
+        initLines.push(`class ${sdkClassName}(BaseClient):`);
+        initLines.push(`    def __init__(self, base_url: str, headers: dict[str, str] | None = None):`);
+        initLines.push(`        super().__init__(base_url, headers)`);
+        for (const c of clientInfos) {
+          initLines.push(`        self.${c.propertyName} = ${c.className}(base_url, headers)`);
+        }
+        initLines.push("");
+      } else {
+        initLines.push(`class ${sdkClassName}(BaseClient):`);
+        initLines.push(`    pass`);
+        initLines.push("");
+      }
+      const allNames = [
+        "BaseClient",
+        "SdkError",
+        sdkClassName,
+        ...clientInfos.map((c) => c.className)
+      ];
+      initLines.push(`__all__ = [${allNames.map((n) => JSON.stringify(n)).join(", ")}]`);
+      initLines.push("");
+      ctx.emitFile(join(outDir, "__init__.py"), initLines.join("\n"));
+    }
+  };
+}
+__name(createPythonSdkPlugin, "createPythonSdkPlugin");
+export {
+  createPythonSdkPlugin,
+  index_default as default
+};
+//# sourceMappingURL=index.js.map