@xyd-js/opensdk-python 0.0.0-build-f0c10f6-20260703195526

package/dist/index.js

@@ -0,0 +1,1246 @@
+// src/emitter.ts
+import { walkMethods } from "@xyd-js/opensdk-core";
+import { generate, planOperation as planOperation3 } from "@xyd-js/opensdk-framework";
+
+// src/method.ts
+function pyPageName(plan) {
+  return plan.pageName === "CursorPage" || plan.pageName === "Page" ? plan.pageName : null;
+}
+
+// src/naming.ts
+function splitWords(input) {
+  return input.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").split(/[^a-zA-Z0-9]+/).map((w) => w.trim().toLowerCase()).filter(Boolean);
+}
+function safeIdent(s) {
+  return /^[0-9]/.test(s) ? `_${s}` : s;
+}
+function pascalCase(input) {
+  const s = splitWords(input).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+  return safeIdent(s);
+}
+function snakeCase(input) {
+  const s = safeIdent(splitWords(input).join("_"));
+  return PY_KEYWORDS.has(s) ? `${s}_` : s;
+}
+function pyModuleName(input) {
+  const s = splitWords(input).join("_").replace(/[^a-z0-9_]/g, "");
+  return s || "client";
+}
+function screamingSnakeCase(input) {
+  return safeIdent(splitWords(input).join("_").toUpperCase().replace(/[^A-Z0-9_]/g, ""));
+}
+var PY_KEYWORDS = /* @__PURE__ */ new Set([
+  "and",
+  "as",
+  "assert",
+  "async",
+  "await",
+  "break",
+  "class",
+  "continue",
+  "def",
+  "del",
+  "elif",
+  "else",
+  "except",
+  "finally",
+  "for",
+  "from",
+  "global",
+  "if",
+  "import",
+  "in",
+  "is",
+  "lambda",
+  "none",
+  "nonlocal",
+  "not",
+  "or",
+  "pass",
+  "raise",
+  "return",
+  "try",
+  "while",
+  "with",
+  "yield"
+]);
+
+// src/project.ts
+import {
+  sdkBehavior
+} from "@xyd-js/opensdk-core";
+import { planOperation } from "@xyd-js/opensdk-framework";
+
+// src/pytype.ts
+var PyUses = class {
+  constructor() {
+    this.typing = /* @__PURE__ */ new Set();
+  }
+  use(name) {
+    this.typing.add(name);
+  }
+  /** The `from typing import ...` line, or null when nothing is used. */
+  typingImport() {
+    if (this.typing.size === 0) return null;
+    const order = ["Any", "BinaryIO", "Optional", "Union"];
+    return `from typing import ${order.filter((n) => this.typing.has(n)).join(", ")}`;
+  }
+};
+function pyType(ref, uses) {
+  if (!ref) return anyType(uses);
+  const base = pyBase(ref, uses);
+  return ref.nullable ? optionalize(base, uses) : base;
+}
+function pyBase(ref, uses) {
+  switch (ref.kind) {
+    case "scalar":
+      return pyScalar(ref.scalar, ref.format, uses);
+    case "ref":
+      return ref.name ? pascalCase(ref.name) : anyType(uses);
+    case "array":
+      return `list[${pyType(ref.items, uses)}]`;
+    case "map":
+      return `dict[str, ${pyType(ref.values, uses)}]`;
+    default:
+      return anyType(uses);
+  }
+}
+function pyScalar(scalar, format, uses) {
+  switch (scalar) {
+    case "string":
+      if (format === "binary") {
+        uses.use("Union");
+        uses.use("BinaryIO");
+        return "Union[bytes, BinaryIO]";
+      }
+      return "str";
+    case "integer":
+      return "int";
+    case "number":
+      return "float";
+    case "boolean":
+      return "bool";
+    default:
+      return anyType(uses);
+  }
+}
+function anyType(uses) {
+  uses.use("Any");
+  return "Any";
+}
+function optionalize(type, uses) {
+  if (type.startsWith("Optional[")) return type;
+  uses.use("Optional");
+  return `Optional[${type}]`;
+}
+function isPassthroughType(type) {
+  return type === "Any" || type === "str" || type === "int" || type === "float" || type === "bool";
+}
+
+// src/project.ts
+function resolvePythonOptions(spec, options) {
+  var _a, _b, _c;
+  const pkg = options.packageName ?? pyModuleName(spec.info.title);
+  return {
+    pkg,
+    baseURL: options.baseURL ?? ((_a = spec.servers) == null ? void 0 : _a[0]) ?? "",
+    envVar: ((_c = (_b = spec.security) == null ? void 0 : _b.find((s) => s.envVar)) == null ? void 0 : _c.envVar) ?? `${screamingSnakeCase(pkg)}_API_KEY`
+  };
+}
+function pyproject(pkg, spec) {
+  var _a, _b;
+  const info = spec.info;
+  const lines = [
+    "[build-system]",
+    'requires = ["setuptools>=61"]',
+    'build-backend = "setuptools.build_meta"',
+    "",
+    "[project]",
+    `name = ${JSON.stringify(pkg.replace(/_/g, "-"))}`,
+    `version = ${JSON.stringify(info.version || "0.0.0")}`
+  ];
+  if (info.description) lines.push(`description = ${JSON.stringify(info.description)}`);
+  lines.push('requires-python = ">=3.9"');
+  if ((_a = info.contact) == null ? void 0 : _a.name) lines.push(`authors = [{ name = ${JSON.stringify(info.contact.name)} }]`);
+  if ((_b = info.license) == null ? void 0 : _b.identifier) lines.push(`license = { text = ${JSON.stringify(info.license.identifier)} }`);
+  const urls = [];
+  if (info.homepage) urls.push(`Homepage = ${JSON.stringify(info.homepage)}`);
+  if (info.repository) urls.push(`Repository = ${JSON.stringify(info.repository)}`);
+  if (urls.length) lines.push("", "[project.urls]", ...urls);
+  lines.push("", "[tool.setuptools.packages.find]", `include = [${JSON.stringify(pkg)}]`);
+  return `${lines.join("\n")}
+`;
+}
+function modelsPy(spec) {
+  const ctx = { uses: new PyUses(), needsField: false };
+  const types = spec.types || [];
+  const aliasKinds = /* @__PURE__ */ new Set(["alias", "union"]);
+  const structsEnums = types.filter((t) => !aliasKinds.has(t.kind));
+  const aliases = orderAliases(types.filter((t) => aliasKinds.has(t.kind)));
+  const decls = [...structsEnums, ...aliases].map((t) => namedType(t, ctx)).filter(Boolean);
+  const lines = [
+    "from __future__ import annotations",
+    "",
+    `from dataclasses import dataclass${ctx.needsField ? ", field" : ""}`,
+    "from enum import Enum"
+  ];
+  const typingLine = ctx.uses.typingImport();
+  if (typingLine) lines.push(typingLine);
+  return `${lines.join("\n")}
+
+
+${decls.join("\n\n\n")}
+`;
+}
+function typeRefNames(ref, out) {
+  if (!ref) return;
+  if (ref.kind === "ref" && ref.name) out.add(ref.name);
+  typeRefNames(ref.items, out);
+  typeRefNames(ref.values, out);
+}
+function orderAliases(aliases) {
+  const byName = new Map(aliases.map((a) => [a.name, a]));
+  const ordered = [];
+  const done = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const visit = (a) => {
+    if (done.has(a.name) || visiting.has(a.name)) return;
+    visiting.add(a.name);
+    const refs = /* @__PURE__ */ new Set();
+    if (a.kind === "alias") typeRefNames(a.of, refs);
+    for (const r of refs) {
+      const dep = byName.get(r);
+      if (dep && dep !== a) visit(dep);
+    }
+    visiting.delete(a.name);
+    done.add(a.name);
+    ordered.push(a);
+  };
+  for (const a of aliases) visit(a);
+  return ordered;
+}
+function namedType(type, ctx) {
+  switch (type.kind) {
+    case "enum":
+      return enumType(type);
+    case "alias":
+      return `${pascalCase(type.name)} = ${pyType(type.of, ctx.uses)}`;
+    case "union":
+      ctx.uses.use("Any");
+      return `${pascalCase(type.name)} = Any`;
+    default:
+      return structType(type, ctx);
+  }
+}
+function structType(type, ctx) {
+  const name = pascalCase(type.name);
+  const fields = type.fields || [];
+  if (fields.length === 0) return `@dataclass
+class ${name}:
+    pass`;
+  const required = fields.filter((f) => f.required);
+  const optional = fields.filter((f) => !f.required);
+  const lines = [...required, ...optional].map((f) => structFieldLine(f, ctx));
+  return `@dataclass
+class ${name}:
+${lines.join("\n")}`;
+}
+function structFieldLine(f, ctx) {
+  const py = snakeCase(f.name);
+  const type = pyType(f.type, ctx.uses);
+  const wire = py === f.name ? null : `metadata={"wire": ${JSON.stringify(f.name)}}`;
+  if (f.required) {
+    if (!wire) return `    ${py}: ${type}`;
+    ctx.needsField = true;
+    return `    ${py}: ${type} = field(${wire})`;
+  }
+  const opt = optionalize(type, ctx.uses);
+  if (!wire) return `    ${py}: ${opt} = None`;
+  ctx.needsField = true;
+  return `    ${py}: ${opt} = field(default=None, ${wire})`;
+}
+function enumType(type) {
+  const name = pascalCase(type.name);
+  const base = type.base === "integer" ? "int" : "str";
+  const values = type.values || [];
+  if (values.length === 0) return `class ${name}(${base}, Enum):
+    pass`;
+  const members = values.map((v) => {
+    const member = screamingSnakeCase(String(v.name ?? v.value)) || "VALUE";
+    const lit = base === "int" ? String(v.value) : JSON.stringify(String(v.value));
+    return `    ${member} = ${lit}`;
+  });
+  return `class ${name}(${base}, Enum):
+${members.join("\n")}`;
+}
+function resourcesPy(spec, types) {
+  const ctx = {
+    types,
+    behavior: sdkBehavior(spec),
+    uses: new PyUses(),
+    transportImports: /* @__PURE__ */ new Set(),
+    pages: /* @__PURE__ */ new Set()
+  };
+  const classes = [];
+  const emit = (resources, parent) => {
+    var _a;
+    for (const r of resources) {
+      const segments = [...parent, r.name];
+      classes.push(resourceClass(r, segments, ctx));
+      if ((_a = r.resources) == null ? void 0 : _a.length) emit(r.resources, segments);
+    }
+  };
+  emit(spec.resources || [], []);
+  const lines = ["from __future__ import annotations", ""];
+  const typingLine = ctx.uses.typingImport();
+  if (typingLine) lines.push(typingLine, "");
+  if (ctx.pages.size > 0) {
+    const pageNames = ["CursorPage", "Page"].filter((n) => ctx.pages.has(n));
+    lines.push(`from ._pagination import ${pageNames.join(", ")}`);
+  }
+  const transportNames = ["Transport", ...["decode", "join_csv"].filter((n) => ctx.transportImports.has(n))];
+  lines.push(`from ._transport import ${transportNames.join(", ")}`);
+  lines.push("from .models import *  # noqa: F401,F403");
+  return `${lines.join("\n")}
+
+
+${classes.join("\n\n\n")}
+`;
+}
+function resourceClassName(segments) {
+  return `${segments.map((s) => pascalCase(s)).join("")}Resource`;
+}
+function resourceClass(resource, segments, ctx) {
+  const cls = resourceClassName(segments);
+  const subs = resource.resources || [];
+  const ctorLines = ["        self._transport = transport"];
+  for (const sub of subs)
+    ctorLines.push(`        self.${snakeCase(sub.name)} = ${resourceClassName([...segments, sub.name])}(transport)`);
+  const ctor = `    def __init__(self, transport: Transport) -> None:
+${ctorLines.join("\n")}`;
+  const methods = (resource.methods || []).map((m) => methodDef(m, ctx));
+  return `class ${cls}:
+${[ctor, ...methods].join("\n\n")}`;
+}
+function methodDef(method, ctx) {
+  const plan = planOperation(method, ctx.types);
+  const name = snakeCase(method.action);
+  const { path: pathParams, query: queryParams, header: headerParams } = plan.paramGroups;
+  const rawContentType = plan.binaryContentType;
+  const positional = pathParams.map((p) => `${snakeCase(p.name)}: ${pyType(p.type, ctx.uses)}`);
+  const kwArgs = [];
+  for (const p of [...queryParams, ...headerParams]) kwArgs.push(paramArg(p, ctx));
+  const bodyParams = bodyFieldList(method, ctx.types);
+  for (const b of bodyParams) {
+    const type = pyType(b.type, ctx.uses);
+    kwArgs.push(
+      b.required ? `${snakeCase(b.name)}: ${type}` : `${snakeCase(b.name)}: ${optionalize(type, ctx.uses)} = None`
+    );
+  }
+  const params = ["self", ...positional, ...kwArgs.length ? ["*", ...kwArgs] : []].join(", ");
+  const httpMethod = method.httpMethod.toUpperCase();
+  const callArgs = [JSON.stringify(httpMethod), pathExpr(method.path, pathParams.length > 0)];
+  if (queryParams.length) {
+    callArgs.push(`query={${queryParams.map((q) => queryEntry(q, ctx)).join(", ")}}`);
+  }
+  if (bodyParams.length) {
+    const entries = bodyParams.map((b) => `${JSON.stringify(b.name)}: ${snakeCase(b.name)}`).join(", ");
+    callArgs.push(`body={${entries}}`);
+  }
+  const headerEntries = headerParams.map((h) => `${JSON.stringify(h.wireName ?? h.name)}: ${snakeCase(h.name)}`);
+  if (rawContentType) headerEntries.unshift(`"Accept": ${JSON.stringify(rawContentType)}`);
+  if (headerEntries.length) callArgs.push(`headers={${headerEntries.join(", ")}}`);
+  let encoding = plan.encoding ?? "json";
+  if (bodyParams.length && encoding === "json" && bodyParams.some((b) => isBinaryTypeRef(b.type, ctx.types))) {
+    encoding = "multipart";
+  }
+  if (bodyParams.length && encoding !== "json") callArgs.push(`encoding=${JSON.stringify(encoding)}`);
+  if (rawContentType) callArgs.push("raw=True");
+  if (plan.injectIdempotencyKey && ctx.behavior.idempotency.autoGenerateForPost) {
+    callArgs.push("idempotency=True");
+  }
+  const call = `self._transport.request(${callArgs.join(", ")})`;
+  const { annotation, body } = returnPlan(plan, call, ctx);
+  const guards = pathParamGuards(pathParams);
+  const fullBody = guards ? `${guards}
+${body}` : body;
+  return `    def ${name}(${params}) -> ${annotation}:
+${fullBody}`;
+}
+function pathParamGuards(pathParams) {
+  var _a;
+  const lines = [];
+  for (const p of pathParams) {
+    if (((_a = p.type) == null ? void 0 : _a.kind) !== "scalar" || p.type.scalar !== "string" || p.required === false) continue;
+    const n = snakeCase(p.name);
+    lines.push(`        if not ${n}:`);
+    lines.push(`            raise ValueError(f"Expected a non-empty value for \`${n}\` but received {${n}!r}")`);
+  }
+  return lines.join("\n");
+}
+function paramArg(p, ctx) {
+  const type = pyType(p.type, ctx.uses);
+  if (p.required) return `${snakeCase(p.name)}: ${type}`;
+  return `${snakeCase(p.name)}: ${optionalize(type, ctx.uses)} = None`;
+}
+function queryEntry(q, ctx) {
+  var _a;
+  const wire = JSON.stringify(q.wireName ?? q.name);
+  const value = snakeCase(q.name);
+  if (((_a = q.type) == null ? void 0 : _a.kind) === "array" && q.explode === false) {
+    ctx.transportImports.add("join_csv");
+    return `${wire}: join_csv(${value})`;
+  }
+  return `${wire}: ${value}`;
+}
+function returnPlan(plan, call, ctx) {
+  var _a;
+  const { method } = plan;
+  if (plan.binaryContentType) return { annotation: "bytes", body: `        return ${call}` };
+  const page = pyPageName(plan);
+  if (page) {
+    ctx.pages.add(page);
+    const item = pyType((_a = method.pagination) == null ? void 0 : _a.itemType, ctx.uses);
+    return { annotation: `${page}[${item}]`, body: `        return ${page}.from_response(${item}, ${call})` };
+  }
+  const primary = method.primaryResponse;
+  if (!primary) return { annotation: "None", body: `        ${call}` };
+  const type = pyType(primary, ctx.uses);
+  if (isPassthroughType(type)) return { annotation: type, body: `        return ${call}` };
+  ctx.transportImports.add("decode");
+  return { annotation: type, body: `        return decode(${type}, ${call})` };
+}
+function isBinaryTypeRef(ref, types, seen = /* @__PURE__ */ new Set()) {
+  if (!ref) return false;
+  if (ref.kind === "scalar") return ref.scalar === "string" && ref.format === "binary";
+  if (ref.kind === "array") return isBinaryTypeRef(ref.items, types, seen);
+  if (ref.kind === "ref" && ref.name) {
+    if (seen.has(ref.name)) return false;
+    seen.add(ref.name);
+    const named = types.get(ref.name);
+    if (!named) return false;
+    if (named.kind === "union") {
+      return (named.variants || []).some((v) => isBinaryTypeRef(v, types, seen));
+    }
+    if (named.kind === "alias") return isBinaryTypeRef(named.of, types, seen);
+  }
+  return false;
+}
+function bodyFieldList(method, types) {
+  var _a;
+  const ref = (_a = method.requestBody) == null ? void 0 : _a.type;
+  if ((ref == null ? void 0 : ref.kind) !== "ref" || !ref.name) return [];
+  const named = types.get(ref.name);
+  return ((named == null ? void 0 : named.fields) || []).map((f) => ({ name: f.name, type: f.type, required: f.required === true }));
+}
+function pathExpr(path, hasParams) {
+  const p = path.startsWith("/") ? path : `/${path}`;
+  if (!hasParams) return JSON.stringify(p);
+  const fstr = p.replace(/\{([^}]+)\}/g, (_, name) => `{${snakeCase(name)}}`);
+  return `f${JSON.stringify(fstr)}`;
+}
+function clientPy(spec, envVar) {
+  const resources = spec.resources || [];
+  const attrLines = resources.map(
+    (r) => `        self.${snakeCase(r.name)} = ${resourceClassName([r.name])}(self._transport)`
+  );
+  const imports = resources.map((r) => resourceClassName([r.name])).join(", ");
+  return `from __future__ import annotations
+
+import os
+from typing import Optional
+
+from ._transport import Transport
+from .resources import ${imports}
+
+
+class Client:
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+        timeout: Optional[float] = None,
+    ) -> None:
+        key = api_key if api_key is not None else os.environ.get(${JSON.stringify(envVar)})
+        self._transport = Transport(base_url=base_url, api_key=key, timeout=timeout)
+${attrLines.join("\n")}
+`;
+}
+
+// src/runtime.ts
+import { sdkBehavior as sdkBehavior2 } from "@xyd-js/opensdk-core";
+function pyStr(value) {
+  return JSON.stringify(value);
+}
+function pyBool(value) {
+  return value ? "True" : "False";
+}
+function pyFloat(value) {
+  return Number.isInteger(value) ? `${value}.0` : String(value);
+}
+function pyFrozenset(items) {
+  return items.length ? `frozenset({${items.join(", ")}})` : "frozenset()";
+}
+function pyStrDict(record) {
+  const entries = Object.entries(record).map(([key, value]) => `${pyStr(key)}: ${pyStr(value)}`);
+  return `{${entries.join(", ")}}`;
+}
+function errorClassName(kind) {
+  if (kind === "API") return "APIError";
+  return kind.endsWith("Error") ? kind : `${kind}Error`;
+}
+function errorClassNames(spec) {
+  const behavior = sdkBehavior2(spec);
+  const names = /* @__PURE__ */ new Set();
+  for (const kind of Object.values(behavior.errors.statusCodeMap)) names.add(errorClassName(kind));
+  names.add(errorClassName(behavior.errors.serverErrorKind));
+  names.add(errorClassName(behavior.errors.clientErrorKind));
+  names.delete("APIError");
+  return [...names].sort();
+}
+function errorClassesBlock(behavior) {
+  const mapped = Object.entries(behavior.errors.statusCodeMap).map(([status, kind]) => [Number(status), kind]).sort((a, b) => a[0] - b[0]);
+  const byClass = /* @__PURE__ */ new Map();
+  for (const [status, kind] of mapped) {
+    const cls = errorClassName(kind);
+    if (cls === "APIError") continue;
+    const entry = byClass.get(cls) || { kind, statuses: [] };
+    entry.statuses.push(status);
+    byClass.set(cls, entry);
+  }
+  const serverClass = errorClassName(behavior.errors.serverErrorKind);
+  const clientClass = errorClassName(behavior.errors.clientErrorKind);
+  const errorClass = (cls, kind, doc) => `class ${cls}(APIError):
+    """${doc}"""
+
+    kind = ${pyStr(kind)}`;
+  const classes = [];
+  for (const [cls, { kind, statuses }] of byClass) {
+    classes.push(errorClass(cls, kind, `The mapped error kind for HTTP ${statuses.join("/")} responses.`));
+  }
+  if (serverClass !== "APIError" && !byClass.has(serverClass)) {
+    classes.push(errorClass(serverClass, behavior.errors.serverErrorKind, "Catch-all for unmapped 5xx responses."));
+  }
+  if (clientClass !== "APIError" && !byClass.has(clientClass) && clientClass !== serverClass) {
+    classes.push(
+      errorClass(clientClass, behavior.errors.clientErrorKind, "Catch-all for unmapped non-5xx error responses.")
+    );
+  }
+  const tableEntries = mapped.map(([status, kind]) => `    ${status}: ${errorClassName(kind)},`);
+  const table = tableEntries.length ? `_STATUS_TO_ERROR: dict[int, type] = {
+${tableEntries.join("\n")}
+}` : "_STATUS_TO_ERROR: dict[int, type] = {}";
+  return `${classes.join("\n\n\n")}
+
+
+${table}
+
+
+def _error_for_status(status_code: int, headers: dict[str, str], body: bytes) -> APIError:
+    """The policy-mapped exception: exact status map first, then the 5xx catch-all, then the client catch-all."""
+    cls = _STATUS_TO_ERROR.get(status_code)
+    if cls is None:
+        cls = ${serverClass} if status_code >= 500 else ${clientClass}
+    return cls(status_code, headers, body)`;
+}
+function transportPy(spec, pkg, baseURL) {
+  var _a;
+  const behavior = sdkBehavior2(spec);
+  const security = (_a = spec.security) == null ? void 0 : _a[0];
+  let authLine = "";
+  if (security) {
+    const name = security.name || "";
+    switch (security.kind) {
+      case "apiKey-header":
+        authLine = `            request_headers[${JSON.stringify(name)}] = self.api_key
+`;
+        break;
+      case "apiKey-query":
+        authLine = `            params[${JSON.stringify(name)}] = self.api_key
+`;
+        break;
+      default:
+        authLine = `            request_headers["Authorization"] = "Bearer " + self.api_key
+`;
+    }
+  }
+  const authBlock = authLine ? `        if self.api_key:
+${authLine}` : "";
+  const userAgent = behavior.userAgent.sdkIdentifierTemplate.replace(/\{package\}/g, pkg).replace(/\{language\}/g, "python").replace(/\{version\}/g, spec.info.version || "0.0.0");
+  const timeoutMs = behavior.timeout.defaultTimeoutMs;
+  const defaultTimeout = timeoutMs > 0 ? pyFloat(timeoutMs / 1e3) : "None";
+  const timeoutEnvVar = behavior.timeout.timeoutEnvVar;
+  const retry = behavior.retry;
+  const errorDocUrlTemplate = behavior.errors.errorDocUrlTemplate;
+  const includeRuntimeVersion = behavior.userAgent.includeRuntimeVersion;
+  const constants = [
+    `DEFAULT_BASE_URL = ${pyStr(baseURL)}`,
+    `USER_AGENT = ${pyStr(userAgent)}`,
+    `AI_AGENT_ENV_VARS = ${pyStrDict(behavior.userAgent.aiAgentEnvVars)}`,
+    `DEFAULT_TIMEOUT: Optional[float] = ${defaultTimeout}`,
+    ...timeoutEnvVar ? [`TIMEOUT_ENV_VAR = ${pyStr(timeoutEnvVar)}`] : [],
+    `MAX_RETRIES = ${retry.maxRetries}`,
+    `RETRYABLE_STATUS_CODES = ${pyFrozenset(retry.retryableStatusCodes.map(String))}`,
+    `RETRY_CONNECTION_ERRORS = ${pyBool(retry.retryConnectionErrors)}`,
+    `HONOR_RETRY_AFTER_HEADER = ${pyBool(retry.honorRetryAfterHeader)}`,
+    `BACKOFF_INITIAL_DELAY = ${pyFloat(retry.backoff.initialDelayMs / 1e3)}`,
+    `BACKOFF_MAX_DELAY = ${pyFloat(retry.backoff.maxDelayMs / 1e3)}`,
+    `BACKOFF_MULTIPLIER = ${pyFloat(retry.backoff.multiplier)}`,
+    `BACKOFF_JITTER = ${pyFloat(retry.backoff.jitter)}`,
+    `REQUEST_ID_HEADER = ${pyStr(behavior.telemetry.requestIdHeader)}`,
+    `IDEMPOTENCY_HEADER = ${pyStr(behavior.idempotency.headerName)}`,
+    ...errorDocUrlTemplate ? [`ERROR_DOC_URL_TEMPLATE = ${pyStr(errorDocUrlTemplate)}`] : [],
+    `GUARDED_OPTION_KEYS = ${pyFrozenset(behavior.requestGuard.optionKeys.map(pyStr))}`
+  ].join("\n");
+  const errorDocStr = errorDocUrlTemplate ? `
+
+    def __str__(self) -> str:
+        url = ERROR_DOC_URL_TEMPLATE.replace("{kind}", self.kind).replace("{status}", str(self.status_code))
+        return self.message + " (" + url + ")"` : "";
+  const runtimeVersionLine = includeRuntimeVersion ? '\n    ua += " python/" + platform.python_version()' : "";
+  return `from __future__ import annotations
+
+import dataclasses
+import datetime
+import email.utils
+import json
+import os${includeRuntimeVersion ? "\nimport platform" : ""}
+import random
+import time
+import typing
+import urllib.error
+import urllib.parse
+import urllib.request
+import uuid
+from enum import Enum
+from typing import Any, Optional
+
+${constants}
+
+
+class APIError(Exception):
+    """A non-2xx API response: status code, headers, raw body, request id and a best-effort message."""
+
+    kind = "API"
+
+    def __init__(self, status_code: int, headers: dict[str, str], body: bytes) -> None:
+        self.status_code = status_code
+        self.headers = headers
+        self.body = body
+        self.request_id = _header(headers, REQUEST_ID_HEADER)
+        self.message = _error_message(body) or "HTTP " + str(status_code)
+        super().__init__(self.message)${errorDocStr}
+
+
+${errorClassesBlock(behavior)}
+
+
+def _error_message(body: bytes) -> Optional[str]:
+    """Best-effort message from a JSON error envelope ({"error": {"message": ...}} etc.)."""
+    try:
+        payload = json.loads(body.decode("utf-8"))
+    except Exception:
+        return None
+    if not isinstance(payload, dict):
+        return None
+    error = payload.get("error")
+    if isinstance(error, dict) and isinstance(error.get("message"), str):
+        return error["message"]
+    if isinstance(error, str):
+        return error
+    for key in ("message", "detail"):
+        if isinstance(payload.get(key), str):
+            return payload[key]
+    return None
+
+
+def _header(headers: dict[str, str], name: str) -> Optional[str]:
+    """Case-insensitive header lookup."""
+    target = name.lower()
+    for key, value in headers.items():
+        if key.lower() == target:
+            return value
+    return None
+
+
+def _user_agent() -> str:
+    """The policy User-Agent: SDK identifier, plus an AI-agent slug when a known agent env var is set."""
+    ua = USER_AGENT${runtimeVersionLine}
+    for env_var, slug in AI_AGENT_ENV_VARS.items():
+        if os.environ.get(env_var):
+            ua += " agent/" + slug
+            break
+    return ua
+
+
+def _default_timeout() -> Optional[float]:
+${timeoutEnvVar ? `    """The policy default timeout in seconds; TIMEOUT_ENV_VAR (milliseconds) overrides it when set."""
+    raw = os.environ.get(TIMEOUT_ENV_VAR)
+    if raw:
+        try:
+            return float(raw) / 1000.0
+        except ValueError:
+            pass
+    return DEFAULT_TIMEOUT` : `    """The policy default timeout in seconds (None = no deadline)."""
+    return DEFAULT_TIMEOUT`}
+
+
+def _retry_delay(attempt: int, headers: Optional[dict[str, str]]) -> float:
+    """Seconds to sleep before retry attempt (0-based): a Retry-After header
+    wins when honored; otherwise min(initial * multiplier**attempt, max) plus
+    proportional random jitter."""
+    if HONOR_RETRY_AFTER_HEADER and headers:
+        retry_after = _retry_after_seconds(headers)
+        if retry_after is not None:
+            return retry_after
+    delay = min(BACKOFF_INITIAL_DELAY * (BACKOFF_MULTIPLIER ** attempt), BACKOFF_MAX_DELAY)
+    return delay + delay * BACKOFF_JITTER * random.random()
+
+
+def _retry_after_seconds(headers: dict[str, str]) -> Optional[float]:
+    """A Retry-After header as seconds: both the integer-seconds and the HTTP-date forms."""
+    value = _header(headers, "Retry-After")
+    if value is None:
+        return None
+    value = value.strip()
+    if value.isdigit():
+        return float(value)
+    try:
+        parsed = email.utils.parsedate_to_datetime(value)
+    except (TypeError, ValueError):
+        return None
+    if parsed is None:
+        return None
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=datetime.timezone.utc)
+    return max(0.0, (parsed - datetime.datetime.now(datetime.timezone.utc)).total_seconds())
+
+
+def _guard_options(params: Optional[dict[str, Any]]) -> None:
+    """Fail fast when a request-option key (api_key, max_retries, ...) is
+    misplaced into request params \u2014 a misplaced credential would otherwise be
+    sent on the wire and end up in provider logs."""
+    for key in params or ():
+        if key in GUARDED_OPTION_KEYS:
+            raise ValueError(
+                "request option " + repr(key) + " must be set on the client, not passed as a request parameter"
+            )
+
+
+def encode(value: Any) -> Any:
+    """Wire-encode a request value: dataclasses -> dicts keyed by wire name
+    (None fields dropped), enums -> their values; lists/dicts recurse."""
+    if isinstance(value, Enum):
+        return encode(value.value)
+    if dataclasses.is_dataclass(value) and not isinstance(value, type):
+        out: dict[str, Any] = {}
+        for f in dataclasses.fields(value):
+            item = getattr(value, f.name)
+            if item is None:
+                continue
+            out[f.metadata.get("wire", f.name)] = encode(item)
+        return out
+    if isinstance(value, (list, tuple)):
+        return [encode(item) for item in value]
+    if isinstance(value, dict):
+        return {key: encode(item) for key, item in value.items()}
+    return value
+
+
+def decode(tp: Any, value: Any) -> Any:
+    """Best-effort decode of parsed JSON into the generated models: dataclasses
+    are built field-by-field (honoring wire names), enums by value; unknown
+    shapes are returned as-is."""
+    if value is None or tp is None or tp is Any:
+        return value
+    origin = typing.get_origin(tp)
+    if origin is not None:
+        args = typing.get_args(tp)
+        if origin is list and isinstance(value, list):
+            item_tp = args[0] if args else Any
+            return [decode(item_tp, item) for item in value]
+        if origin is dict and isinstance(value, dict):
+            value_tp = args[1] if len(args) > 1 else Any
+            return {key: decode(value_tp, item) for key, item in value.items()}
+        if origin is typing.Union:
+            for arg in args:
+                if arg is type(None):
+                    continue
+                try:
+                    decoded = decode(arg, value)
+                except Exception:
+                    continue
+                if decoded is not value:
+                    return decoded
+            return value
+        return value
+    if isinstance(tp, type) and issubclass(tp, Enum):
+        try:
+            return tp(value)
+        except ValueError:
+            return value
+    if isinstance(tp, type) and dataclasses.is_dataclass(tp) and isinstance(value, dict):
+        try:
+            hints = typing.get_type_hints(tp)
+        except Exception:
+            hints = {}
+        kwargs: dict[str, Any] = {}
+        for f in dataclasses.fields(tp):
+            wire = f.metadata.get("wire", f.name)
+            if wire in value:
+                kwargs[f.name] = decode(hints.get(f.name, Any), value[wire])
+            elif f.default is dataclasses.MISSING and f.default_factory is dataclasses.MISSING:
+                kwargs[f.name] = None
+        return tp(**kwargs)
+    return value
+
+
+def join_csv(value: Optional[list]) -> Optional[str]:
+    """Serialize an explode=false array parameter as one comma-joined value."""
+    if value is None:
+        return None
+    return ",".join(_text(encode(item)) for item in value)
+
+
+def _text(value: Any) -> str:
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, (dict, list)):
+        return json.dumps(value)
+    return str(value)
+
+
+def _query_value(value: Any) -> Any:
+    encoded = encode(value)
+    if isinstance(encoded, list):
+        return [_text(item) for item in encoded]
+    return _text(encoded)
+
+
+def _multipart(payload: dict[str, Any]) -> tuple[bytes, str]:
+    """Encode a multipart/form-data body (stdlib-only, manual boundary).
+    bytes / file-like values become file parts; lists become repeated parts."""
+    boundary = uuid.uuid4().hex
+    chunks: list[bytes] = []
+    for name, value in payload.items():
+        items = value if isinstance(value, list) else [value]
+        for item in items:
+            chunks.append(("--" + boundary + "\\r\\n").encode("utf-8"))
+            if isinstance(item, bytes) or hasattr(item, "read"):
+                content = item if isinstance(item, bytes) else item.read()
+                if isinstance(content, str):
+                    content = content.encode("utf-8")
+                filename = str(getattr(item, "name", name)).replace("\\\\", "/").split("/")[-1] or name
+                disposition = 'Content-Disposition: form-data; name="' + name + '"; filename="' + filename + '"\\r\\n'
+                chunks.append(disposition.encode("utf-8"))
+                chunks.append(b"Content-Type: application/octet-stream\\r\\n\\r\\n")
+                chunks.append(content)
+            else:
+                chunks.append(('Content-Disposition: form-data; name="' + name + '"\\r\\n\\r\\n').encode("utf-8"))
+                chunks.append(_text(item).encode("utf-8"))
+            chunks.append(b"\\r\\n")
+    chunks.append(("--" + boundary + "--\\r\\n").encode("utf-8"))
+    return b"".join(chunks), "multipart/form-data; boundary=" + boundary
+
+
+class Transport:
+    def __init__(
+        self,
+        base_url: Optional[str] = None,
+        api_key: Optional[str] = None,
+        timeout: Optional[float] = None,
+    ) -> None:
+        self.base_url = (base_url or DEFAULT_BASE_URL).rstrip("/")
+        self.api_key = api_key
+        self.timeout = timeout if timeout is not None else _default_timeout()
+        self.user_agent = _user_agent()
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        query: Optional[dict[str, Any]] = None,
+        body: Optional[dict[str, Any]] = None,
+        headers: Optional[dict[str, Any]] = None,
+        encoding: str = "json",
+        raw: bool = False,
+        idempotency: bool = False,
+    ) -> Any:
+        _guard_options(query)
+        _guard_options(body)
+        url = self.base_url + path
+        params = {k: _query_value(v) for k, v in (query or {}).items() if v is not None}
+        request_headers: dict[str, str] = {k: _text(v) for k, v in (headers or {}).items() if v is not None}
+        request_headers.setdefault("User-Agent", self.user_agent)
+        data = None
+        if body is not None:
+            payload = {k: encode(v) for k, v in body.items() if v is not None}
+            if encoding == "multipart":
+                data, content_type = _multipart(payload)
+                request_headers["Content-Type"] = content_type
+            elif encoding == "form":
+                data = urllib.parse.urlencode(payload, doseq=True).encode("utf-8")
+                request_headers["Content-Type"] = "application/x-www-form-urlencoded"
+            else:
+                data = json.dumps(payload).encode("utf-8")
+                request_headers["Content-Type"] = "application/json"
+${authBlock}        if idempotency:
+            # One key per logical call, generated before the retry loop so every
+            # retry of this request carries the SAME idempotency key.
+            request_headers.setdefault(IDEMPOTENCY_HEADER, str(uuid.uuid4()))
+        if params:
+            url += "?" + urllib.parse.urlencode(params, doseq=True)
+        attempt = 0
+        while True:
+            request = urllib.request.Request(url, data=data, method=method, headers=request_headers)
+            try:
+                with urllib.request.urlopen(request, timeout=self.timeout) as response:
+                    content = response.read()
+            except urllib.error.HTTPError as error:
+                error_headers = dict(error.headers.items())
+                error_body = error.read()
+                if attempt < MAX_RETRIES and error.code in RETRYABLE_STATUS_CODES:
+                    time.sleep(_retry_delay(attempt, error_headers))
+                    attempt += 1
+                    continue
+                raise _error_for_status(error.code, error_headers, error_body) from None
+            except OSError:
+                # Connection/timeout errors (URLError, reset, DNS failure, socket timeout).
+                if RETRY_CONNECTION_ERRORS and attempt < MAX_RETRIES:
+                    time.sleep(_retry_delay(attempt, None))
+                    attempt += 1
+                    continue
+                raise
+            if raw:
+                return content
+            return json.loads(content.decode("utf-8")) if content else None
+`;
+}
+function paginationPy() {
+  return `from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Generic, Iterator, TypeVar
+
+from ._transport import decode
+
+T = TypeVar("T")
+
+
+@dataclass
+class CursorPage(Generic[T]):
+    """One page of a cursor-paginated list: \`data\` plus a \`has_more\` marker."""
+
+    data: list[T] = field(default_factory=list)
+    has_more: bool = False
+
+    def __iter__(self) -> Iterator[T]:
+        return iter(self.data)
+
+    @classmethod
+    def from_response(cls, item_type: Any, raw: Any) -> CursorPage[T]:
+        payload = raw if isinstance(raw, dict) else {}
+        data = [decode(item_type, item) for item in payload.get("data") or []]
+        return cls(data=data, has_more=bool(payload.get("has_more") or False))
+
+
+@dataclass
+class Page(Generic[T]):
+    """One page of a marker-less list: the whole collection in one \`data\` envelope."""
+
+    data: list[T] = field(default_factory=list)
+
+    def __iter__(self) -> Iterator[T]:
+        return iter(self.data)
+
+    @classmethod
+    def from_response(cls, item_type: Any, raw: Any) -> Page[T]:
+        payload = raw if isinstance(raw, dict) else {}
+        return cls(data=[decode(item_type, item) for item in payload.get("data") or []])
+`;
+}
+
+// src/tests-py.ts
+import { planMethodExample, planOperation as planOperation2 } from "@xyd-js/opensdk-framework";
+
+// src/example-py.ts
+function renderPyExample(value) {
+  switch (value.kind) {
+    case "string":
+      return pyStr2(value.value);
+    case "integer":
+      return String(value.value);
+    case "number":
+      return String(value.value);
+    case "boolean":
+      return value.value ? "True" : "False";
+    case "null":
+      return "None";
+    case "binary":
+      return 'b"Example data"';
+    case "enum":
+      return pyLiteral(value.value);
+    case "const":
+      return pyLiteral(value.value);
+    case "array":
+      return `[${renderPyExample(value.item)}]`;
+    case "map":
+      return `{"key": ${renderPyExample(value.value)}}`;
+    case "object":
+      return value.fields.length === 0 ? "{}" : `{${value.fields.map((f) => `${pyStr2(f.name)}: ${renderPyExample(f.value)}`).join(", ")}}`;
+    case "union":
+      return renderPyExample(value.variant);
+    default:
+      return "None";
+  }
+}
+function pyLiteral(v) {
+  if (v === null || v === void 0) return "None";
+  if (typeof v === "boolean") return v ? "True" : "False";
+  if (typeof v === "number") return String(v);
+  return pyStr2(String(v));
+}
+function pyStr2(s) {
+  return JSON.stringify(s);
+}
+
+// src/tests-py.ts
+var DEFAULT_BASE_URL = "http://127.0.0.1:4010";
+function testUtilsPy() {
+  return `from __future__ import annotations
+
+import typing
+from typing import Any
+
+
+def assert_matches_type(expected_type: Any, value: Any, *, path: Any = None) -> None:
+    """Pragmatic structural check for the generated test suite.
+
+    Verifies the SHAPE of a response without being strict about deep generics:
+    dataclass instances, the vendored pagination containers, primitives, lists
+    and dicts are all accepted. A parameterized generic (e.g. CursorPage[Pet],
+    list[str]) is matched against its ORIGIN only; Any / object / typing
+    constructs (Optional, Union, ...) always match.
+    """
+    origin = typing.get_origin(expected_type)
+    if origin is not None:
+        expected_type = origin
+    if expected_type is Any or expected_type is object or expected_type is None:
+        return
+    if not isinstance(expected_type, type):
+        return
+    assert isinstance(value, expected_type), (
+        f"expected {getattr(expected_type, '__name__', expected_type)!r}, "
+        f"got {type(value).__name__!r} (path={path})"
+    )
+`;
+}
+function testConftestPy(pkg) {
+  return `from __future__ import annotations
+
+import os
+
+import pytest
+
+from ${pkg} import Client
+
+base_url = os.environ.get("TEST_API_BASE_URL", ${JSON.stringify(DEFAULT_BASE_URL)})
+
+
+@pytest.fixture
+def client() -> Client:
+    return Client(api_key="My API Key", base_url=base_url)
+`;
+}
+function collectMethods(resource, chain, namePrefix, out) {
+  for (const method of resource.methods || []) out.push({ method, chain, namePrefix });
+  for (const sub of resource.resources || []) {
+    const attr = snakeCase(sub.name);
+    collectMethods(sub, [...chain, attr], `${namePrefix}${attr}_`, out);
+  }
+}
+function firstStringPathParam(method) {
+  var _a;
+  for (const p of method.pathParams || []) {
+    if (((_a = p.type) == null ? void 0 : _a.kind) === "scalar" && p.type.scalar === "string" && p.required !== false) return p;
+  }
+  return null;
+}
+function responseTypeExpr(method, types, uses, pages) {
+  var _a;
+  const plan = planOperation2(method, types);
+  if (plan.binaryContentType) return "bytes";
+  const page = pyPageName(plan);
+  if (page) {
+    pages.add(page);
+    return `${page}[${pyType((_a = method.pagination) == null ? void 0 : _a.itemType, uses)}]`;
+  }
+  const primary = method.primaryResponse;
+  if (!primary) return null;
+  return pyType(primary, uses);
+}
+function renderCallArgs(ex) {
+  const parts = ex.pathArgs.map((pa) => renderPyExample(pa.value));
+  for (const f of ex.fields) parts.push(`${snakeCase(f.name)}=${renderPyExample(f.value)}`);
+  return parts.join(", ");
+}
+function renderMethodTest(name, call, responseType) {
+  const lines = [`    def ${name}(self, client: Client) -> None:`];
+  if (responseType) {
+    lines.push(`        result = ${call}`);
+    lines.push(`        assert_matches_type(${responseType}, result, path=["response"])`);
+  } else {
+    lines.push(`        ${call}`);
+  }
+  return lines.join("\n");
+}
+function renderPathParamsTest(name, callChain, ex, target) {
+  const n = snakeCase(target.name);
+  const parts = [];
+  for (const pa of ex.pathArgs) parts.push(pa.param === target ? '""' : renderPyExample(pa.value));
+  for (const f of ex.fields) parts.push(`${snakeCase(f.name)}=${renderPyExample(f.value)}`);
+  return [
+    `    def ${name}(self, client: Client) -> None:`,
+    `        with pytest.raises(ValueError, match=r"Expected a non-empty value for \`${n}\` but received ''"):`,
+    `            ${callChain}(${parts.join(", ")})`
+  ].join("\n");
+}
+function resourceTestPy(resource, pkg, types) {
+  const uses = new PyUses();
+  const pages = /* @__PURE__ */ new Set();
+  let usesPytest = false;
+  const collected = [];
+  collectMethods(resource, [snakeCase(resource.name)], "", collected);
+  const blocks = [];
+  for (const { method, chain, namePrefix } of collected) {
+    const action = snakeCase(method.action);
+    const base = `${namePrefix}${action}`;
+    const callChain = `client.${[...chain, action].join(".")}`;
+    const responseType = responseTypeExpr(method, types, uses, pages);
+    const required = planMethodExample(method, types);
+    blocks.push(renderMethodTest(`test_method_${base}`, `${callChain}(${renderCallArgs(required)})`, responseType));
+    if (required.hasOptional) {
+      const all = planMethodExample(method, types, { withOptional: true });
+      blocks.push(
+        renderMethodTest(`test_method_${base}_with_all_params`, `${callChain}(${renderCallArgs(all)})`, responseType)
+      );
+    }
+    const target = firstStringPathParam(method);
+    if (target) {
+      usesPytest = true;
+      blocks.push(renderPathParamsTest(`test_path_params_${base}`, callChain, required, target));
+    }
+  }
+  const groups = [["from __future__ import annotations"]];
+  const typingLine = uses.typingImport();
+  if (typingLine) groups.push([typingLine]);
+  if (usesPytest) groups.push(["import pytest"]);
+  const local = ["from tests.utils import assert_matches_type", `from ${pkg} import Client`, `from ${pkg}.models import *  # noqa: F401,F403`];
+  if (pages.size > 0) {
+    const names = ["CursorPage", "Page"].filter((n) => pages.has(n));
+    local.push(`from ${pkg}._pagination import ${names.join(", ")}`);
+  }
+  groups.push(local);
+  const imports = groups.map((g) => g.join("\n")).join("\n\n");
+  const body = blocks.length ? blocks.join("\n\n") : "    pass";
+  return `${imports}
+
+
+class Test${pascalCase(resource.name)}:
+${body}
+`;
+}
+
+// src/emitter.ts
+var resolve = (spec, ctx) => resolvePythonOptions(spec, ctx.emitterOptions);
+var pythonEmitter = {
+  language: "python",
+  fileHeader() {
+    return "Code generated by opensdk. DO NOT EDIT.";
+  },
+  generateProject(spec, ctx) {
+    const { pkg } = resolve(spec, ctx);
+    return [{ path: "pyproject.toml", content: pyproject(pkg, spec), writeMode: "skipIfExists" }];
+  },
+  generateClient(spec, ctx) {
+    const { pkg, envVar } = resolve(spec, ctx);
+    const errors = ["APIError", ...errorClassNames(spec)];
+    const all = ["Client", ...errors].sort();
+    const init = `from ._client import Client
+from ._transport import ${errors.join(", ")}
+
+__all__ = [${all.map((n) => JSON.stringify(n)).join(", ")}]
+`;
+    return [
+      { path: `${pkg}/__init__.py`, content: init },
+      { path: `${pkg}/_client.py`, content: clientPy(spec, envVar) }
+    ];
+  },
+  // models.py is emitted even for an empty symbol table: resources.py
+  // star-imports it, so the module must always exist.
+  generateTypes(_types, ctx) {
+    const { pkg } = resolve(ctx.spec, ctx);
+    return [{ path: `${pkg}/models.py`, content: modelsPy(ctx.spec) }];
+  },
+  generateResources(_resources, ctx) {
+    const { pkg } = resolve(ctx.spec, ctx);
+    return [{ path: `${pkg}/resources.py`, content: resourcesPy(ctx.spec, ctx.types) }];
+  },
+  generateRuntime(spec, ctx) {
+    const { pkg, baseURL } = resolve(spec, ctx);
+    const files = [{ path: `${pkg}/_transport.py`, content: transportPy(spec, pkg, baseURL) }];
+    if (walkMethods(spec).some(({ method }) => pyPageName(planOperation3(method, ctx.types)) !== null)) {
+      files.push({ path: `${pkg}/_pagination.py`, content: paginationPy() });
+    }
+    return files;
+  },
+  // The SDK's own pytest suite (openai-python's tests/api_resources/*). SYNC
+  // only — no async/raw/streaming client yet (follow-ups). Off via
+  // emitterOptions.tests === false; default ON. One test file per top-level
+  // resource plus the shared conftest fixture + assert_matches_type helper.
+  generateTests(spec, ctx) {
+    if (ctx.emitterOptions.tests === false) return [];
+    const { pkg } = resolve(spec, ctx);
+    const resources = spec.resources || [];
+    if (resources.length === 0) return [];
+    const files = [
+      { path: "tests/utils.py", content: testUtilsPy() },
+      { path: "tests/conftest.py", content: testConftestPy(pkg) }
+    ];
+    for (const r of resources) {
+      files.push({ path: `tests/test_${snakeCase(r.name)}.py`, content: resourceTestPy(r, pkg, ctx.types) });
+    }
+    return files;
+  }
+};
+function opensdkPython(spec, options = {}) {
+  return generate(spec, pythonEmitter, options);
+}
+
+// src/publish.ts
+import { runCommand } from "@xyd-js/opensdk-framework";
+function publishPython(dir, opts = {}) {
+  runCommand("python3", ["-m", "build"], { cwd: dir });
+  if (opts.dryRun) return;
+  const args = ["upload"];
+  if (opts.registry) args.push("--repository-url", opts.registry);
+  args.push("dist/*");
+  runCommand("twine", args, {
+    cwd: dir,
+    env: {
+      ...process.env,
+      TWINE_USERNAME: process.env.TWINE_USERNAME ?? "__token__",
+      TWINE_PASSWORD: opts.token ?? process.env.TWINE_PASSWORD ?? "opensdk"
+    }
+  });
+}
+
+// src/index.ts
+import { writeProject } from "@xyd-js/opensdk-framework";
+export {
+  opensdkPython,
+  publishPython,
+  pythonEmitter,
+  writeProject
+};
+//# sourceMappingURL=index.js.map