@autorest/python 6.19.0 → 6.21.0

package/scripts/{run-tests.ts → eng/run-tests.ts}

@@ -4,28 +4,28 @@ import { readFileSync } from "fs";
 import { join } from "path";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
+import { fileURLToPath } from "url";
 
 interface Arguments {
+    validFolders: string[];
     folder?: string;
     command?: string;
+    name?: string;
 }
 
-const validFolders = [
-    "azure/legacy",
-    "azure/version-tolerant",
-    "vanilla/legacy",
-    "vanilla/version-tolerant",
-    "dpg/version-tolerant",
-];
-
 const validCommands = ["ci", "lint", "mypy", "pyright", "apiview"];
 
 // Parse command-line arguments using yargs
 const argv = yargs(hideBin(process.argv))
+    .option("validFolders", {
+        alias: "vf",
+        describe: "Specify the valid folders",
+        type: "array",
+        default: ["azure", "unbranded"],
+    })
     .option("folder", {
         alias: "f",
         describe: "Specify the folder to use",
-        choices: validFolders,
         type: "string",
     })
     .option("command", {
@@ -33,30 +33,39 @@ const argv = yargs(hideBin(process.argv))
         describe: "Specify the command to run",
         choices: validCommands,
         type: "string",
+    })
+    .option("name", {
+        alias: "n",
+        describe: "Specify the name of the test",
+        type: "string",
     }).argv as Arguments;
 
-const foldersToProcess = argv.folder ? [argv.folder] : validFolders;
+const foldersToProcess = argv.folder ? [argv.folder] : argv.validFolders;
 
 const commandToRun = argv.command || "all";
 
-function getCommand(command: string, folder: string) {
+function getCommand(command: string, folder: string, name?: string): string {
     if (!validCommands.includes(command)) throw new Error(`Unknown command '${command}'.`);
-    return `FOLDER=${folder} tox -c ./test/${folder}/tox.ini -e ${command}`;
+    const retval = `FOLDER=${folder} tox -c ./test/${folder}/tox.ini -e ${command}`;
+    if (name) {
+        return `${retval} -- -f ${name}`;
+    }
+    return retval;
 }
 
 function sectionExistsInToxIni(command: string, folder: string): boolean {
-    const toxIniPath = join(__dirname, `../test/${folder}/tox.ini`);
+    const toxIniPath = join(fileURLToPath(import.meta.url), `../../../test/${folder}/tox.ini`);
     const toxIniContent = readFileSync(toxIniPath, "utf-8");
     const sectionHeader = `[testenv:${command}]`;
     return toxIniContent.includes(sectionHeader);
 }
 
-function myExecSync(command: string, folder: string): void {
+function myExecSync(command: string, folder: string, name?: string): void {
     if (!sectionExistsInToxIni(command, folder)) {
         console.log(`No section for ${command} in tox.ini for folder ${folder}. Skipping...`);
         return;
     }
-    execSync(getCommand(command, folder), { stdio: "inherit" });
+    execSync(getCommand(command, folder, name), { stdio: "inherit" });
 }
 
 foldersToProcess.forEach((folder) => {
@@ -64,11 +73,11 @@ foldersToProcess.forEach((folder) => {
         if (commandToRun === "all") {
             for (const key of validCommands) {
                 console.log(`Running ${key} for folder ${folder}...`);
-                myExecSync(key, folder);
+                myExecSync(key, folder, argv.name);
             }
-        } else if (getCommand(commandToRun, folder)) {
+        } else if (getCommand(commandToRun, folder, argv.name)) {
             console.log(`Running ${commandToRun} for folder ${folder}...`);
-            myExecSync(commandToRun, folder);
+            myExecSync(commandToRun, folder, argv.name);
         } else {
             console.error(`Error: Unknown command '${commandToRun}'.`);
             process.exit(1);

package/scripts/eng/utils.ts

@@ -0,0 +1,38 @@
+/* eslint-disable no-console */
+import { exec } from "child_process";
+import process from "process";
+import { existsSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import chalk from "chalk";
+
+// execute the command
+export function executeCommand(command: string, prettyName: string) {
+    exec(command, (error, stdout, stderr) => {
+        if (error) {
+            console.error(chalk.red(`Error executing ${command}(stdout): ${stdout}`));
+            console.error(chalk.red(`Error executing ${command}{stderr}: ${stderr}`));
+            process.exit(1);
+        }
+        if (stderr) {
+            // Process stderr output
+            console.log(chalk.yellow(`${command}:\n${stderr}`));
+            return;
+        }
+        console.log(chalk.green(`${prettyName} passed`));
+    });
+}
+
+// Function to run a command and log the output
+export function runCommand(command: string, prettyName: string) {
+    let pythonPath = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "venv/");
+    if (existsSync(join(pythonPath, "bin"))) {
+        pythonPath = join(pythonPath, "bin", "python");
+    } else if (existsSync(join(pythonPath, "Scripts"))) {
+        pythonPath = join(pythonPath, "Scripts", "python");
+    } else {
+        throw new Error(pythonPath);
+    }
+    command = `${pythonPath} -m ${command}`;
+    executeCommand(command, prettyName);
+}

package/scripts/mypy.ini

@@ -0,0 +1,38 @@
+# global configurations
+[mypy]
+python_version = 3.8
+
+
+# module level configuratiohns
+[mypy-jsonrpc.*]
+ignore_missing_imports = True
+
+[mypy-ptvsd.*]
+ignore_missing_imports = True
+
+[mypy-debugpy.*]
+ignore_missing_imports = True
+
+[mypy-m2r2.*]
+ignore_missing_imports = True
+
+[mypy-autorest.common.utils.*]
+ignore_missing_imports = True
+
+[mypy-autorest.common.python_mappings.*]
+ignore_missing_imports = True
+
+[mypy-pygen.codegen.models.*]
+ignore_missing_imports = True
+
+[mypy-setuptools]
+ignore_missing_imports = True
+
+[mypy-*._patch]
+ignore_missing_imports = True
+
+[mypy-pygen.*]
+ignore_missing_imports = True
+
+[mypy-yaml.*]
+ignore_missing_imports = True

package/scripts/run-python3.ts

@@ -0,0 +1,25 @@
+// This script wraps logic in @azure-tools/extension to resolve
+// the path to Python 3 so that a Python script file can be run
+// from an npm script in package.json.  It uses the same Python 3
+// path resolution algorithm as AutoRest so that the behavior
+// is fully consistent (and also supports AUTOREST_PYTHON_EXE).
+//
+// Invoke it like so: "tsx run-python3.ts script.py"
+
+import cp from "child_process";
+import { patchPythonPath } from "./system-requirements.js";
+
+async function runPython3(...args: string[]) {
+    const command = await patchPythonPath(["python", ...args], {
+        version: ">=3.8",
+        environmentVariable: "AUTOREST_PYTHON_EXE",
+    });
+    cp.execSync(command.join(" "), {
+        stdio: [0, 1, 2],
+    });
+}
+
+runPython3(...process.argv.slice(2)).catch((err) => {
+    console.error(err.toString()); // eslint-disable-line no-console
+    process.exit(1);
+});

package/scripts/system-requirements.ts

@@ -0,0 +1,253 @@
+import { SpawnOptions, ChildProcess, spawn } from "child_process";
+import { coerce, satisfies } from "semver";
+
+/*
+ * Copied from @autorest/system-requirements
+ */
+
+const execute = (command: string, cmdlineargs: Array<string>, options: MoreOptions = {}): Promise<ExecResult> => {
+    return new Promise((resolve, reject) => {
+        const cp = spawn(command, cmdlineargs, { ...options, stdio: "pipe", shell: true });
+        if (options.onCreate) {
+            options.onCreate(cp);
+        }
+
+        options.onStdOutData ? cp.stdout.on("data", options.onStdOutData) : cp;
+        options.onStdErrData ? cp.stderr.on("data", options.onStdErrData) : cp;
+
+        let err = "";
+        let out = "";
+        let all = "";
+        cp.stderr.on("data", (chunk) => {
+            err += chunk;
+            all += chunk;
+        });
+        cp.stdout.on("data", (chunk) => {
+            out += chunk;
+            all += chunk;
+        });
+
+        cp.on("error", (err) => {
+            reject(err);
+        });
+        cp.on("close", (code, signal) =>
+            resolve({
+                stdout: out,
+                stderr: err,
+                log: all,
+                error: code ? new Error("Process Failed.") : null,
+                code,
+            }),
+        );
+    });
+};
+
+const versionIsSatisfied = (version: string, requirement: string): boolean => {
+    const cleanedVersion = coerce(version);
+    if (!cleanedVersion) {
+        throw new Error(`Invalid version ${version}.`);
+    }
+    return satisfies(cleanedVersion, requirement, true);
+};
+
+/**
+ * Validate the provided system requirement resolution is satisfying the version requirement if applicable.
+ * @param resolution Command resolution.
+ * @param actualVersion Version for that resolution.
+ * @param requirement Requirement.
+ * @returns the resolution if it is valid or an @see SystemRequirementError if not.
+ */
+const validateVersionRequirement = (
+    resolution: SystemRequirementResolution,
+    actualVersion: string,
+    requirement: SystemRequirement,
+): SystemRequirementResolution | SystemRequirementError => {
+    if (!requirement.version) {
+        return resolution; // No version requirement.
+    }
+
+    try {
+        if (versionIsSatisfied(actualVersion, requirement.version)) {
+            return resolution;
+        }
+        return {
+            ...resolution,
+            error: true,
+            message: `'${resolution.command}' version is '${actualVersion}' but doesn't satisfy requirement '${requirement.version}'. Please update.`,
+            actualVersion: actualVersion,
+            neededVersion: requirement.version,
+        };
+    } catch {
+        return {
+            ...resolution,
+            error: true,
+            message: `Couldn't parse the version ${actualVersion}. This is not a valid semver version.`,
+            actualVersion: actualVersion,
+            neededVersion: requirement.version,
+        };
+    }
+};
+
+const tryPython = async (
+    requirement: SystemRequirement,
+    command: string,
+    additionalArgs: string[] = [],
+): Promise<SystemRequirementResolution | SystemRequirementError> => {
+    const resolution: SystemRequirementResolution = {
+        name: PythonRequirement,
+        command,
+        additionalArgs: additionalArgs.length > 0 ? additionalArgs : undefined,
+    };
+
+    try {
+        const result = await execute(command, [...additionalArgs, "-c", `"${PRINT_PYTHON_VERSION_SCRIPT}"`]);
+        return validateVersionRequirement(resolution, result.stdout.trim(), requirement);
+    } catch (e) {
+        return {
+            error: true,
+            ...resolution,
+            message: `'${command}' command line is not found in the path. Make sure to have it installed.`,
+        };
+    }
+};
+
+/**
+ * Returns the path to the executable as asked in the requirement.
+ * @param requirement System requirement definition.
+ * @returns If the requirement provide an environment variable for the path returns the value of that environment variable. undefined otherwise.
+ */
+const getExecutablePath = (requirement: SystemRequirement): string | undefined =>
+    requirement.environmentVariable && process.env[requirement.environmentVariable];
+
+const createPythonErrorMessage = (
+    requirement: SystemRequirement,
+    errors: SystemRequirementError[],
+): SystemRequirementError => {
+    const versionReq = requirement.version ?? "*";
+    const lines = [
+        `Couldn't find a valid python interpreter satisfying the requirement (version: ${versionReq}). Tried:`,
+        ...errors.map((x) => ` - ${x.command} (${x.message})`),
+    ];
+
+    return {
+        error: true,
+        name: "python",
+        command: "python",
+        message: lines.join("\n"),
+    };
+};
+
+const resolvePythonRequirement = async (
+    requirement: SystemRequirement,
+): Promise<SystemRequirementResolution | SystemRequirementError> => {
+    // Hardcoding AUTOREST_PYTHON_EXE is for backward compatibility
+    const path = getExecutablePath(requirement) ?? process.env["AUTOREST_PYTHON_EXE"];
+    if (path) {
+        return await tryPython(requirement, path);
+    }
+
+    const errors: SystemRequirementError[] = [];
+    // On windows try `py` executable with `-3` flag.
+    if (process.platform === "win32") {
+        const pyResult = await tryPython(requirement, "py", ["-3"]);
+        if ("error" in pyResult) {
+            errors.push(pyResult);
+        } else {
+            return pyResult;
+        }
+    }
+
+    const python3Result = await tryPython(requirement, "python3");
+    if ("error" in python3Result) {
+        errors.push(python3Result);
+    } else {
+        return python3Result;
+    }
+
+    const pythonResult = await tryPython(requirement, "python");
+    if ("error" in pythonResult) {
+        errors.push(pythonResult);
+    } else {
+        return pythonResult;
+    }
+
+    return createPythonErrorMessage(requirement, errors);
+};
+
+/**
+ * @param command list of the command and arguments. First item in array must be a python exe @see KnownPythonExe. (e.g. ["python", "mypythonfile.py"]
+ * @param requirement
+ */
+export const patchPythonPath = async (
+    command: PythonCommandLine,
+    requirement: SystemRequirement,
+): Promise<string[]> => {
+    const [_, ...args] = command;
+    const resolution = await resolvePythonRequirement(requirement);
+    if ("error" in resolution) {
+        throw new Error(`Failed to find compatible python version. ${resolution.message}`);
+    }
+    return [resolution.command, ...(resolution.additionalArgs ?? []), ...args];
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// TYPES
+const PythonRequirement = "python";
+const PRINT_PYTHON_VERSION_SCRIPT = "import sys; print('.'.join(map(str, sys.version_info[:3])))";
+
+type KnownPythonExe = "python.exe" | "python3.exe" | "python" | "python3";
+type PythonCommandLine = [KnownPythonExe, ...string[]];
+
+interface MoreOptions extends SpawnOptions {
+    onCreate?(cp: ChildProcess): void;
+    onStdOutData?(chunk: any): void;
+    onStdErrData?(chunk: any): void;
+}
+
+interface SystemRequirement {
+    version?: string;
+    /**
+     * Name of an environment variable where the user could provide the path to the exe.
+     * @example "AUTOREST_PYTHON_PATH"
+     */
+    environmentVariable?: string;
+}
+
+interface SystemRequirementResolution {
+    /**
+     * Name of the requirement.
+     * @example python, java, etc.
+     */
+    name: string;
+
+    /**
+     * Name of the command
+     * @example python3, /home/myuser/python39/python, java, etc.
+     */
+    command: string;
+
+    /**
+     * List of additional arguments to pass to this command.
+     * @example '-3' for 'py' to specify to use python 3
+     */
+    additionalArgs?: string[];
+}
+
+interface ExecResult {
+    stdout: string;
+    stderr: string;
+
+    /**
+     * Union of stdout and stderr.
+     */
+    log: string;
+    error: Error | null;
+    code: number | null;
+}
+
+interface SystemRequirementError extends SystemRequirementResolution {
+    error: true;
+    message: string;
+    neededVersion?: string;
+    actualVersion?: string;
+}

package/scripts/copy-generator.js

@@ -1,19 +0,0 @@
-const fs = require("fs-extra");
-const path = require("path");
-
-const force = process.argv[2] === "--force" ? true : false;
-
-const typespecModulePath = path.join(__dirname, "..", "node_modules", "@azure-tools", "typespec-python");
-
-// Define the source and destination directories
-const sourceDir = path.join(typespecModulePath, "generator");
-const destDir = path.join(__dirname, "..", "generator");
-
-// Delete the destination directory if it exists
-if (fs.existsSync(destDir)) {
-    if (force) fs.removeSync(destDir);
-    else process.exit(0);
-}
-
-// Copy the source directory to the destination directory
-fs.copySync(sourceDir, destDir);