@typespec/http-client-python 0.28.3 → 0.29.0

package/emitter/src/emitter.ts

@@ -1,17 +1,30 @@
 import { createSdkContext } from "@azure-tools/typespec-client-generator-core";
-import { EmitContext, NoTarget } from "@typespec/compiler";
+import { EmitContext, emitFile, joinPaths, NoTarget } from "@typespec/compiler";
 import { execSync } from "child_process";
 import fs from "fs";
+import jsyaml from "js-yaml";
 import os from "os";
 import path, { dirname } from "path";
-import { loadPyodide } from "pyodide";
+import { loadPyodide, PyodideInterface } from "pyodide";
 import { fileURLToPath } from "url";
+import pkgJson from "../../package.json" with { type: "json" };
 import { emitCodeModel } from "./code-model.js";
+import {
+  blackExcludeDirs,
+  BLOB_STORAGE_BASE_URL,
+  PACKAGE_NAME,
+  PYGEN_WHEEL_FILENAME,
+  PYODIDE_VERSION,
+} from "./constants.js";
 import { saveCodeModelAsYaml } from "./external-process.js";
 import { PythonEmitterOptions, PythonSdkContext, reportDiagnostic } from "./lib.js";
 import { runPython3 } from "./run-python3.js";
 import { getRootNamespace, md2Rst } from "./utils.js";
 
+function getBrowserPygenWheelUrl(): string {
+  return `${BLOB_STORAGE_BASE_URL}/${PACKAGE_NAME}/${pkgJson.version}/generator/dist/${PYGEN_WHEEL_FILENAME}`;
+}
+
 function addDefaultOptions(sdkContext: PythonSdkContext) {
   const defaultOptions = {
     "package-version": "1.0.0b1",
@@ -29,21 +42,24 @@ function addDefaultOptions(sdkContext: PythonSdkContext) {
     const packageName = namespace.replace(/\./g, "-");
     options["package-name"] = packageName;
   }
-  if ((options as any).flavor !== "azure") {
-    // if they pass in a flavor other than azure, we want to ignore the value
-    (options as any).flavor = undefined;
-  }
+  // Set flavor based on namespace or passed option
   if (getRootNamespace(sdkContext).toLowerCase().includes("azure")) {
     (options as any).flavor = "azure";
+  } else if ((options as any).flavor !== "azure") {
+    // Explicitly set unbranded flavor when not azure
+    (options as any).flavor = "unbranded";
   }
 
   if (
     options["package-pprint-name"] !== undefined &&
     !options["package-pprint-name"].startsWith('"')
   ) {
-    options["package-pprint-name"] = options["use-pyodide"]
-      ? `${options["package-pprint-name"]}`
-      : `"${options["package-pprint-name"]}"`;
+    // Only add quotes for shell compatibility when NOT using emit-yaml-only mode
+    // (emit-yaml-only passes options via JSON config files, not shell)
+    const needsShellQuoting = !options["use-pyodide"] && !options["emit-yaml-only"];
+    options["package-pprint-name"] = needsShellQuoting
+      ? `"${options["package-pprint-name"]}"`
+      : `${options["package-pprint-name"]}`;
   }
 }
 
@@ -102,6 +118,60 @@ function walkThroughNodes(yamlMap: Record<string, any>): Record<string, any> {
   return yamlMap;
 }
 
+const pyodideGenerationCode = `
+async def main():
+  import warnings
+  with warnings.catch_warnings():
+    from pygen import preprocess, codegen, black
+  preprocess.PreProcessPlugin(output_folder=outputFolder, tsp_file=yamlFile, **commandArgs).process()
+  codegen.CodeGenerator(output_folder=outputFolder, tsp_file=yamlFile, **commandArgs).process()
+  black.BlackScriptPlugin(output_folder=outputFolder, **commandArgs).process()
+
+await main()`;
+
+async function runPyodideGeneration(
+  pyodide: PyodideInterface,
+  outputFolder: string,
+  yamlFile: string,
+  commandArgs: Record<string, string>,
+) {
+  const globals = pyodide.toPy({
+    outputFolder,
+    yamlFile,
+    commandArgs,
+  });
+
+  await pyodide.runPythonAsync(pyodideGenerationCode, { globals });
+}
+
+async function copyPyodideOutputToHost(
+  context: EmitContext<PythonEmitterOptions>,
+  pyodide: PyodideInterface,
+  memfsDir: string,
+  relativeDir: string = "",
+) {
+  const entries = pyodide.FS.readdir(memfsDir).filter(
+    (entry: string) => entry !== "." && entry !== "..",
+  );
+
+  for (const entry of entries) {
+    const memfsPath = `${memfsDir}/${entry}`;
+    const relativePath = relativeDir ? `${relativeDir}/${entry}` : entry;
+    const stats = pyodide.FS.stat(memfsPath);
+
+    if (pyodide.FS.isDir(stats.mode)) {
+      await copyPyodideOutputToHost(context, pyodide, memfsPath, relativePath);
+      continue;
+    }
+
+    const content = pyodide.FS.readFile(memfsPath, { encoding: "utf8" });
+    await emitFile(context.program, {
+      path: joinPaths(context.emitterOutputDir, relativePath),
+      content,
+    });
+  }
+}
+
 export async function $onEmit(context: EmitContext<PythonEmitterOptions>) {
   try {
     await onEmitMain(context);
@@ -122,13 +192,21 @@ export async function $onEmit(context: EmitContext<PythonEmitterOptions>) {
 async function onEmitMain(context: EmitContext<PythonEmitterOptions>) {
   const program = context.program;
   const sdkContext = await createPythonSdkContext(context);
-  const root = path.join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+
   const outputDir = context.emitterOutputDir;
   addDefaultOptions(sdkContext);
   const yamlMap = emitCodeModel(sdkContext);
   const parsedYamlMap = walkThroughNodes(yamlMap);
 
-  const yamlPath = await saveCodeModelAsYaml("python-yaml-path", parsedYamlMap);
+  // Python emitter requires an SDK client in the TypeSpec
+  if (sdkContext.sdkPackage.clients.length === 0) {
+    reportDiagnostic(program, {
+      code: "no-sdk-clients",
+      target: NoTarget,
+    });
+    return;
+  }
+
   const resolvedOptions = sdkContext.emitContext.options;
   const commandArgs: Record<string, string> = {};
   if (resolvedOptions["packaging-files-config"]) {
@@ -155,99 +233,141 @@ async function onEmitMain(context: EmitContext<PythonEmitterOptions>) {
   commandArgs["from-typespec"] = "true";
   commandArgs["models-mode"] = (resolvedOptions as any)["models-mode"] ?? "dpg";
 
-  if (!program.compilerOptions.noEmit && !program.hasError()) {
-    // if not using pyodide and there's no venv, we try to create venv
-    if (!resolvedOptions["use-pyodide"] && !fs.existsSync(path.join(root, "venv"))) {
-      try {
-        await runPython3(path.join(root, "/eng/scripts/setup/install.py"));
-        await runPython3(path.join(root, "/eng/scripts/setup/prepare.py"));
-      } catch {
-        // if the python env is not ready, we use pyodide instead
-        resolvedOptions["use-pyodide"] = true;
-      }
+  if (typeof window !== "undefined") {
+    // Running in browser with Pyodide - fileURLToPath and other filesystem operations are browser-incompatible
+    const pyodide = await browserPyodidePromise;
+
+    if (!pyodide) {
+      reportDiagnostic(program, {
+        code: "browser-runtime-load-failed",
+        target: NoTarget,
+        format: { details: "" },
+      });
+      return;
     }
 
-    if (resolvedOptions["use-pyodide"]) {
-      // here we run with pyodide
-      const pyodide = await setupPyodideCall(root);
-      // create the output folder if not exists
-      if (!fs.existsSync(outputDir)) {
-        fs.mkdirSync(outputDir, { recursive: true });
+    const yamlFilePath = "/yaml/python-yaml-path.yaml";
+    pyodide.FS.mkdirTree("/yaml");
+    pyodide.FS.mkdirTree("/output");
+    clearMemfsDirectory(pyodide, "/output");
+    pyodide.FS.writeFile(yamlFilePath, jsyaml.dump(parsedYamlMap));
+
+    await runPyodideGeneration(pyodide, "/output", yamlFilePath, commandArgs);
+    await copyPyodideOutputToHost(context, pyodide, "/output");
+  } else {
+    const root = path.join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+    const yamlPath = await saveCodeModelAsYaml("python-yaml-path", parsedYamlMap);
+
+    if (!program.compilerOptions.noEmit && !program.hasError()) {
+      // If emit-yaml-only mode, just copy YAML to output dir for batch processing
+      if (resolvedOptions["emit-yaml-only"]) {
+        if (!fs.existsSync(outputDir)) {
+          fs.mkdirSync(outputDir, { recursive: true });
+        }
+        // Copy YAML to output dir with command args embedded
+        // Use unique filename to avoid conflicts when multiple specs share output dir
+        const configId = path.basename(yamlPath, ".yaml");
+        const batchConfig = { yamlPath, commandArgs, outputDir };
+        fs.writeFileSync(
+          path.join(outputDir, `.tsp-codegen-${configId}.json`),
+          JSON.stringify(batchConfig, null, 2),
+        );
+        return;
       }
-      // mount output folder to pyodide
-      pyodide.FS.mkdirTree("/output");
-      pyodide.FS.mount(pyodide.FS.filesystems.NODEFS, { root: outputDir }, "/output");
-      // mount yaml file to pyodide
-      pyodide.FS.mkdirTree("/yaml");
-      pyodide.FS.mount(pyodide.FS.filesystems.NODEFS, { root: path.dirname(yamlPath) }, "/yaml");
-      const globals = pyodide.toPy({
-        outputFolder: "/output",
-        yamlFile: `/yaml/${path.basename(yamlPath)}`,
-        commandArgs,
-      });
-      const pythonCode = `
-          async def main():
-            import warnings
-            with warnings.catch_warnings():
-              from pygen import preprocess, codegen, black
-            preprocess.PreProcessPlugin(output_folder=outputFolder, tsp_file=yamlFile, **commandArgs).process()
-            codegen.CodeGenerator(output_folder=outputFolder, tsp_file=yamlFile, **commandArgs).process()
-            black.BlackScriptPlugin(output_folder=outputFolder, **commandArgs).process()
-      
-          await main()`;
-      await pyodide.runPythonAsync(pythonCode, { globals });
-    } else {
-      // here we run with native python
-      let venvPath = path.join(root, "venv");
-      if (fs.existsSync(path.join(venvPath, "bin"))) {
-        venvPath = path.join(venvPath, "bin", "python");
-      } else if (fs.existsSync(path.join(venvPath, "Scripts"))) {
-        venvPath = path.join(venvPath, "Scripts", "python.exe");
+      // if not using pyodide and there's no venv, we try to create venv
+      if (!resolvedOptions["use-pyodide"] && !fs.existsSync(path.join(root, "venv"))) {
+        try {
+          await runPython3(path.join(root, "/eng/scripts/setup/install.py"));
+          await runPython3(path.join(root, "/eng/scripts/setup/prepare.py"));
+        } catch {
+          // if the python env is not ready, we use pyodide instead
+          resolvedOptions["use-pyodide"] = true;
+        }
+      }
+
+      if (resolvedOptions["use-pyodide"]) {
+        // here we run with pyodide
+        const pyodide = await setupPyodideCall(root);
+        // create the output folder if not exists
+        if (!fs.existsSync(outputDir)) {
+          fs.mkdirSync(outputDir, { recursive: true });
+        }
+        // mount output folder to pyodide
+        pyodide.FS.mkdirTree("/output");
+        pyodide.FS.mount(pyodide.FS.filesystems.NODEFS, { root: outputDir }, "/output");
+        // mount yaml file to pyodide
+        pyodide.FS.mkdirTree("/yaml");
+        pyodide.FS.mount(pyodide.FS.filesystems.NODEFS, { root: path.dirname(yamlPath) }, "/yaml");
+        await runPyodideGeneration(
+          pyodide,
+          "/output",
+          `/yaml/${path.basename(yamlPath)}`,
+          commandArgs,
+        );
       } else {
-        reportDiagnostic(program, {
-          code: "pyodide-flag-conflict",
-          target: NoTarget,
-        });
+        // here we run with native python
+        let venvPath = path.join(root, "venv");
+        if (fs.existsSync(path.join(venvPath, "bin"))) {
+          venvPath = path.join(venvPath, "bin", "python");
+        } else if (fs.existsSync(path.join(venvPath, "Scripts"))) {
+          venvPath = path.join(venvPath, "Scripts", "python.exe");
+        } else {
+          reportDiagnostic(program, {
+            code: "pyodide-flag-conflict",
+            target: NoTarget,
+          });
+        }
+        commandArgs["output-folder"] = outputDir;
+        commandArgs["tsp-file"] = yamlPath;
+        const commandFlags = Object.entries(commandArgs)
+          .map(([key, value]) => `--${key}=${value}`)
+          .join(" ");
+        const command = `${venvPath} ${root}/eng/scripts/setup/run_tsp.py ${commandFlags}`;
+        execSync(command);
+
+        const excludePattern = blackExcludeDirs.join("|");
+        execSync(
+          `${venvPath} -m black --line-length=120 --quiet --fast ${outputDir} --exclude "${excludePattern}"`,
+        );
+        await checkForPylintIssues(outputDir, excludePattern);
       }
-      commandArgs["output-folder"] = outputDir;
-      commandArgs["tsp-file"] = yamlPath;
-      const commandFlags = Object.entries(commandArgs)
-        .map(([key, value]) => `--${key}=${value}`)
-        .join(" ");
-      const command = `${venvPath} ${root}/eng/scripts/setup/run_tsp.py ${commandFlags}`;
-      execSync(command);
-
-      const blackExcludeDirs = [
-        "__pycache__/",
-        "node_modules/",
-        "venv/",
-        "env/",
-        ".direnv",
-        ".eggs",
-        ".git",
-        ".hg",
-        ".tox",
-        ".venv",
-        ".eggs",
-        ".mypy_cache",
-        ".pytest_cache",
-        ".vscode",
-        ".*_build/",
-        "/build/",
-        "dist",
-        ".nox",
-        ".svn",
-        "TempTypeSpecFiles/",
-      ];
-      const excludePattern = blackExcludeDirs.join("|");
-      execSync(
-        `${venvPath} -m black --line-length=120 --quiet --fast ${outputDir} --exclude "${excludePattern}"`,
-      );
-      await checkForPylintIssues(outputDir, excludePattern);
     }
   }
 }
 
+const browserPyodidePromise: Promise<PyodideInterface> | null =
+  typeof window !== "undefined" ? setupPyodideCallBrowser() : null;
+
+function clearMemfsDirectory(pyodide: PyodideInterface, dir: string): void {
+  const entries: string[] = pyodide.FS.readdir(dir).filter(
+    (entry: string) => entry !== "." && entry !== "..",
+  );
+  for (const entry of entries) {
+    const fullPath = `${dir}/${entry}`;
+    const stats = pyodide.FS.stat(fullPath);
+    if (pyodide.FS.isDir(stats.mode)) {
+      clearMemfsDirectory(pyodide, fullPath);
+      pyodide.FS.rmdir(fullPath);
+    } else {
+      pyodide.FS.unlink(fullPath);
+    }
+  }
+}
+
+async function setupPyodideCallBrowser() {
+  const pyodide = await loadPyodide({
+    indexURL: `https://cdn.jsdelivr.net/pyodide/v${PYODIDE_VERSION}/full/`,
+  });
+
+  // use default MEMFS for browser, since NODEFS is not supported
+  pyodide.FS.mkdirTree("/generator");
+  await pyodide.loadPackage("micropip");
+  const micropip = pyodide.pyimport("micropip");
+  await micropip.install(getBrowserPygenWheelUrl());
+
+  return pyodide;
+}
+
 async function setupPyodideCall(root: string) {
   const pyodide = await loadPyodide({
     indexURL: path.dirname(fileURLToPath(import.meta.resolve("pyodide"))),
@@ -277,7 +397,7 @@ async function setupPyodideCall(root: string) {
       );
       await pyodide.loadPackage("micropip");
       const micropip = pyodide.pyimport("micropip");
-      await micropip.install("emfs:/generator/dist/pygen-0.1.0-py3-none-any.whl");
+      await micropip.install(`emfs:/generator/dist/${PYGEN_WHEEL_FILENAME}`);
       fs.closeSync(fd);
       fs.unlinkSync(micropipLockPath);
       break;

package/emitter/src/http.ts

@@ -1,4 +1,4 @@
-import { NoTarget } from "@typespec/compiler";
+import { getNamespaceFullName, NoTarget } from "@typespec/compiler";
 
 import {
   getHttpOperationParameter,
@@ -19,6 +19,7 @@ import {
   SdkQueryParameter,
   SdkServiceMethod,
   SdkServiceResponseHeader,
+  SdkType,
   UsageFlags,
 } from "@azure-tools/typespec-client-generator-core";
 import { HttpStatusCodeRange } from "@typespec/http";
@@ -41,6 +42,32 @@ export enum ReferredByOperationTypes {
   NonPagingOnly = 2,
 }
 
+function isEtagType(type: SdkType): boolean {
+  if (type.kind === "nullable") return isEtagType(type.type);
+  const raw = type.__raw;
+  if (!raw || raw.kind !== "Scalar") return false;
+  return (
+    raw.name === "eTag" &&
+    raw.namespace !== undefined &&
+    getNamespaceFullName(raw.namespace) === "Azure.Core"
+  );
+}
+
+function getEtagRole(parameter: SdkHeaderParameter): string | undefined {
+  const name = parameter.name.toLowerCase();
+  const wire = parameter.serializedName.toLowerCase();
+  // Standard If-Match / If-None-Match headers work with any type
+  if (wire === "if-match") return "ifMatch";
+  if (wire === "if-none-match") return "ifNoneMatch";
+  // Non-standard headers require Azure.Core.eTag type
+  if (!isEtagType(parameter.type)) return undefined;
+  if (name.includes("nonematch") || name.includes("none_match")) return "ifNoneMatch";
+  if (name.includes("match")) return "ifMatch";
+  if (wire.endsWith("-if-none-match")) return "ifNoneMatch";
+  if (wire.endsWith("-if-match")) return "ifMatch";
+  return undefined;
+}
+
 function isContentTypeParameter(parameter: SdkHeaderParameter) {
   return parameter.serializedName.toLowerCase() === "content-type";
 }
@@ -496,6 +523,7 @@ function emitHttpHeaderParameter(
     delimiter,
     explode,
     clientDefaultValue,
+    etagRole: getEtagRole(parameter),
   };
 }
 

package/emitter/src/lib.ts

@@ -25,6 +25,7 @@ export interface PythonEmitterOptions {
   "use-pyodide"?: boolean;
   "keep-setup-py"?: boolean;
   "clear-output-folder"?: boolean;
+  "emit-yaml-only"?: boolean;
 }
 
 export interface PythonSdkContext extends SdkContext<PythonEmitterOptions> {
@@ -110,6 +111,12 @@ export const PythonEmitterOptionsSchema: JSONSchemaType<PythonEmitterOptions> =
       description:
         "Whether to clear the output folder before generating the code. Defaults to `false`.",
     },
+    "emit-yaml-only": {
+      type: "boolean",
+      nullable: true,
+      description:
+        "Emit YAML code model only, without running Python generator. For batch processing.",
+    },
   },
   required: [],
 };
@@ -131,6 +138,19 @@ const libDef = {
           "Python is not installed. Please follow https://www.python.org/ to install Python or set 'use-pyodide' to true.",
       },
     },
+    "no-sdk-clients": {
+      severity: "error",
+      messages: {
+        default:
+          "The Python emitter did not find any SDK clients in this TypeSpec program. The current Python generator expects at least one client/service to generate code.",
+      },
+    },
+    "browser-runtime-load-failed": {
+      severity: "error",
+      messages: {
+        default: paramMessage`Failed to initialize the browser Python runtime.${"details"}`,
+      },
+    },
     "invalid-paging-items": {
       severity: "warning",
       messages: {

package/emitter/src/run-python3.ts

@@ -11,7 +11,7 @@ import { patchPythonPath } from "./system-requirements.js";
 
 export async function runPython3(...args: string[]) {
   const command = await patchPythonPath(["python", ...args], {
-    version: ">=3.9",
+    version: ">=3.10",
     environmentVariable: "AUTOREST_PYTHON_EXE",
   });
   cp.execSync(command.join(" "), {

package/emitter/src/types.ts

@@ -249,6 +249,7 @@ function emitProperty(
     isMultipartFileInput: isMultipartFileInput,
     xmlMetadata: getXmlMetadata(property),
     encode: property.encode,
+    clientDefaultValue: property.clientDefaultValue,
   };
 }
 
@@ -377,9 +378,6 @@ function emitEnum(context: PythonSdkContext, type: SdkEnumType): Record<string,
 }
 
 function enumName(name: string): string {
-  if (name.toUpperCase() === name) {
-    return name;
-  }
   return camelToSnakeCase(name).toUpperCase();
 }
 
@@ -547,6 +545,22 @@ export const KnownTypes = {
   any: { type: "any" },
 };
 
+/**
+ * Detect whether an endpoint template parameter should be treated as an API
+ * version parameter even when TCGC does not flag it as such.  This is a
+ * compatibility shim for unreleased TCGC changes that gate the name-based
+ * heuristic on `isMetadata`, which excludes server template parameters.
+ */
+function isEndpointApiVersionFallback(
+  param: { name: string; isApiVersionParam: boolean },
+  serviceApiVersions: string[],
+): boolean {
+  if (param.isApiVersionParam) return false;
+  if (serviceApiVersions.length === 0) return false;
+  const lower = param.name.toLowerCase();
+  return lower === "apiversion" || lower === "api-version";
+}
+
 export function emitEndpointType(
   context: PythonSdkContext,
   type: SdkEndpointType,
@@ -556,13 +570,29 @@ export function emitEndpointType(
   for (const param of type.templateArguments) {
     const paramBase = emitParamBase(context, param, undefined, serviceApiVersions);
     paramBase.clientName = context.arm ? "base_url" : paramBase.clientName;
+
+    let effectiveClientDefaultValue = param.clientDefaultValue;
+    // If this endpoint template param looks like an api-version but TCGC
+    // did not flag it, apply fallback: mark as api version and derive defaults.
+    if (isEndpointApiVersionFallback(param, serviceApiVersions)) {
+      paramBase.isApiVersion = true;
+      if (!effectiveClientDefaultValue) {
+        effectiveClientDefaultValue = serviceApiVersions[serviceApiVersions.length - 1];
+      }
+      paramBase.type = getSimpleTypeResult(context, {
+        type: "constant",
+        value: effectiveClientDefaultValue,
+        valueType: paramBase.type,
+      });
+    }
+
     params.push({
       ...paramBase,
-      optional: Boolean(param.clientDefaultValue),
+      optional: Boolean(effectiveClientDefaultValue),
       wireName: param.name,
       location: "endpointPath",
       implementation: getImplementation(context, param),
-      clientDefaultValue: param.clientDefaultValue,
+      clientDefaultValue: effectiveClientDefaultValue,
       skipUrlEncoding: param.allowReserved,
     });
     context.__endpointPathParameters!.push(params.at(-1)!);