@autorest/python 6.18.0 → 6.20.0

package/scripts/eng/regenerate.ts

@@ -0,0 +1,298 @@
+/* eslint-disable no-console */
+import { exec as execCallback } from "child_process";
+import { promisify } from "util";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { dirname, join, relative, resolve } from "path";
+import { promises, rmSync } from "fs";
+import { fileURLToPath } from "url";
+
+// Promisify the exec function
+const exec = promisify(execCallback);
+
+// Get the directory of the current file
+const PLUGIN_DIR = resolve(fileURLToPath(import.meta.url), "../../../");
+const CADL_RANCH_DIR = resolve(PLUGIN_DIR, "node_modules/@azure-tools/cadl-ranch-specs/http");
+interface TspCommand {
+    outputDir: string;
+    command: string;
+}
+
+const EMITTER_OPTIONS: Record<string, Record<string, string> | Record<string, string>[]> = {
+    "resiliency/srv-driven/old.tsp": {
+        "package-name": "resiliency-srv-driven1",
+        "package-mode": "azure-dataplane",
+        "package-pprint-name": "ResiliencySrvDriven1",
+    },
+    "resiliency/srv-driven": {
+        "package-name": "resiliency-srv-driven2",
+        "package-mode": "azure-dataplane",
+        "package-pprint-name": "ResiliencySrvDriven2",
+    },
+    "authentication/http/custom": {
+        "package-name": "authentication-http-custom",
+    },
+    "authentication/union": {
+        "package-name": "authentication-union",
+    },
+    "type/array": {
+        "package-name": "typetest-array",
+    },
+    "type/dictionary": {
+        "package-name": "typetest-dictionary",
+    },
+    "type/enum/extensible": {
+        "package-name": "typetest-enum-extensible",
+    },
+    "type/enum/fixed": {
+        "package-name": "typetest-enum-fixed",
+    },
+    "type/model/empty": {
+        "package-name": "typetest-model-empty",
+    },
+    "type/model/flatten": {
+        "package-name": "typetest-model-flatten",
+    },
+    "type/model/inheritance/enum-discriminator": {
+        "package-name": "typetest-model-enumdiscriminator",
+    },
+    "type/model/inheritance/nested-discriminator": {
+        "package-name": "typetest-model-nesteddiscriminator",
+    },
+    "type/model/inheritance/not-discriminated": {
+        "package-name": "typetest-model-notdiscriminated",
+    },
+    "type/model/inheritance/single-discriminator": {
+        "package-name": "typetest-model-singlediscriminator",
+    },
+    "type/model/inheritance/recursive": {
+        "package-name": "typetest-model-recursive",
+    },
+    "type/model/usage": {
+        "package-name": "typetest-model-usage",
+    },
+    "type/model/visibility": [
+        { "package-name": "typetest-model-visibility" },
+        { "package-name": "headasbooleantrue", "head-as-boolean": "true" },
+        { "package-name": "headasbooleanfalse", "head-as-boolean": "false" },
+    ],
+    "type/property/nullable": {
+        "package-name": "typetest-property-nullable",
+    },
+    "type/property/optionality": {
+        "package-name": "typetest-property-optional",
+    },
+    "type/property/additional-properties": {
+        "package-name": "typetest-property-additionalproperties",
+    },
+    "type/scalar": {
+        "package-name": "typetest-scalar",
+    },
+    "type/property/value-types": {
+        "package-name": "typetest-property-valuetypes",
+    },
+    "type/union": {
+        "package-name": "typetest-union",
+    },
+    "azure/core/lro/rpc": {
+        "package-name": "azurecore-lro-rpc",
+    },
+    "client/structure/multi-client": {
+        "package-name": "client-structure-multiclient",
+    },
+    "client/structure/renamed-operation": {
+        "package-name": "client-structure-renamedoperation",
+    },
+    "client/structure/two-operation-group": {
+        "package-name": "client-structure-twooperationgroup",
+    },
+    "mgmt/sphere": [{ "package-name": "azure-mgmt-spheredpg" }],
+};
+
+function toPosix(dir: string): string {
+    return dir.replace(/\\/g, "/");
+}
+
+function getEmitterOption(spec: string): Record<string, string>[] {
+    const relativeSpec = toPosix(relative(CADL_RANCH_DIR, spec));
+    const key = relativeSpec.includes("resiliency/srv-driven/old.tsp") ? relativeSpec : dirname(relativeSpec);
+    const result = EMITTER_OPTIONS[key] || [{}];
+    return Array.isArray(result) ? result : [result];
+}
+
+// Function to execute CLI commands asynchronously
+async function executeCommand(tspCommand: TspCommand): Promise<void> {
+    try {
+        rmSync(tspCommand.outputDir, { recursive: true, force: true });
+    } catch (error) {
+        console.error(`rm error: ${error}`);
+    }
+    try {
+        console.log(`exec: ${tspCommand.command}`);
+        const { stdout, stderr } = await exec(tspCommand.command);
+        if (stdout) console.log(`stdout: ${stdout}`);
+        if (stderr) console.error(`stderr: ${stderr}`);
+    } catch (error) {
+        console.error(`exec error: ${error}`);
+        throw error;
+    }
+}
+
+interface RegenerateFlagsInput {
+    flavor?: "azure" | "unbranded";
+    debug?: boolean;
+    name?: string;
+}
+
+interface RegenerateFlags {
+    flavor: "azure" | "unbranded";
+    debug: boolean;
+    name?: string;
+}
+
+const SpecialFlags: Record<string, Record<string, any>> = {
+    azure: {
+        "generate-test": true,
+        "generate-sample": true,
+    },
+};
+
+async function getSubdirectories(baseDir: string, flags: RegenerateFlags): Promise<string[]> {
+    const subdirectories: string[] = [];
+
+    async function searchDir(currentDir: string) {
+        const items = await promises.readdir(currentDir, { withFileTypes: true });
+
+        const promisesArray = items.map(async (item) => {
+            const subDirPath = join(currentDir, item.name);
+            if (item.isDirectory()) {
+                const mainTspPath = join(subDirPath, "main.tsp");
+                const clientTspPath = join(subDirPath, "client.tsp");
+
+                const mainTspRelativePath = toPosix(relative(baseDir, mainTspPath));
+                if (flags.flavor === "unbranded" && mainTspRelativePath.includes("azure")) return;
+
+                // after xml support, remove this check
+                if (mainTspRelativePath.includes("xml")) return;
+
+                // after fix test generation for nested operation group, remove this check
+                if (mainTspRelativePath.includes("client-operation-group")) return;
+
+                const hasMainTsp = await promises
+                    .access(mainTspPath)
+                    .then(() => true)
+                    .catch(() => false);
+                const hasClientTsp = await promises
+                    .access(clientTspPath)
+                    .then(() => true)
+                    .catch(() => false);
+
+                if (mainTspRelativePath.toLowerCase().includes(flags.name || "")) {
+                    if (mainTspRelativePath.includes("resiliency/srv-driven")) {
+                        subdirectories.push(resolve(subDirPath, "old.tsp"));
+                    }
+                    if (hasClientTsp) {
+                        subdirectories.push(resolve(subDirPath, "client.tsp"));
+                    } else if (hasMainTsp) {
+                        subdirectories.push(resolve(subDirPath, "main.tsp"));
+                    }
+                }
+
+                // Recursively search in the subdirectory
+                await searchDir(subDirPath);
+            }
+        });
+
+        await Promise.all(promisesArray);
+    }
+
+    await searchDir(baseDir);
+    return subdirectories;
+}
+
+function defaultPackageName(spec: string): string {
+    return toPosix(relative(CADL_RANCH_DIR, dirname(spec)))
+        .replace(/\//g, "-")
+        .toLowerCase();
+}
+
+interface EmitterConfig {
+    optionsStr: string;
+    outputDir: string;
+}
+
+function addOptions(spec: string, generatedFolder: string, flags: RegenerateFlags): EmitterConfig[] {
+    const emitterConfigs: EmitterConfig[] = [];
+    for (const config of getEmitterOption(spec)) {
+        const options: Record<string, string> = { ...config };
+        options["flavor"] = flags.flavor;
+        for (const [k, v] of Object.entries(SpecialFlags[flags.flavor] ?? {})) {
+            options[k] = v;
+        }
+        if (options["emitter-output-dir"] === undefined) {
+            const packageName = options["package-name"] || defaultPackageName(spec);
+            options["emitter-output-dir"] = toPosix(`${generatedFolder}/test/${flags.flavor}/generated/${packageName}`);
+        }
+        if (flags.debug) {
+            options["debug"] = "true";
+        }
+        if (flags.flavor === "unbranded") {
+            options["company-name"] = "Unbranded";
+        }
+        options["examples-dir"] = toPosix(join(dirname(spec), "examples"));
+        const configs = Object.entries(options).flatMap(([k, v]) => {
+            return `--option @azure-tools/typespec-python.${k}=${v}`;
+        });
+        emitterConfigs.push({
+            optionsStr: configs.join(" "),
+            outputDir: options["emitter-output-dir"],
+        });
+    }
+    return emitterConfigs;
+}
+function _getCmdList(spec: string, flags: RegenerateFlags): TspCommand[] {
+    return addOptions(spec, PLUGIN_DIR, flags).map((option) => {
+        return {
+            outputDir: option.outputDir,
+            command: `tsp compile ${spec} --emit=${toPosix(PLUGIN_DIR)} ${option.optionsStr}`,
+        };
+    });
+}
+
+async function regenerate(flags: RegenerateFlagsInput): Promise<void> {
+    if (flags.flavor === undefined) {
+        await regenerate({ ...flags, flavor: "azure" });
+        await regenerate({ ...flags, flavor: "unbranded" });
+    } else {
+        const flagsResolved = { debug: false, flavor: flags.flavor, ...flags };
+        const CADL_RANCH_DIR = resolve(PLUGIN_DIR, "node_modules/@azure-tools/cadl-ranch-specs/http");
+        const subdirectories = await getSubdirectories(CADL_RANCH_DIR, flagsResolved);
+        const cmdList: TspCommand[] = subdirectories.flatMap((subdirectory) =>
+            _getCmdList(subdirectory, flagsResolved),
+        );
+        const PromiseCommands = cmdList.map((tspCommand) => executeCommand(tspCommand));
+        await Promise.all(PromiseCommands);
+    }
+}
+
+// PARSE INPUT ARGUMENTS
+const argv = yargs(hideBin(process.argv))
+    .option("flavor", {
+        type: "string",
+        choices: ["azure", "unbranded"],
+        description: "Specify the flavor",
+    })
+    .option("debug", {
+        alias: "d",
+        type: "boolean",
+        description: "Debug mode",
+    })
+    .option("name", {
+        alias: "n",
+        type: "string",
+        description: "Specify filename if you only want to generate a subset",
+    }).argv;
+
+regenerate(argv as RegenerateFlags)
+    .then(() => console.log("Regeneration successful"))
+    .catch((error) => console.error(`Regeneration failed: ${error.message}`));

package/scripts/eng/run-tests.ts

@@ -0,0 +1,80 @@
+/* eslint-disable no-console */
+import { execSync } from "child_process";
+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;
+}
+
+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",
+        type: "string",
+    })
+    .option("command", {
+        alias: "c",
+        describe: "Specify the command to run",
+        choices: validCommands,
+        type: "string",
+    }).argv as Arguments;
+
+const foldersToProcess = argv.folder ? [argv.folder] : argv.validFolders;
+
+const commandToRun = argv.command || "all";
+
+function getCommand(command: string, folder: string) {
+    if (!validCommands.includes(command)) throw new Error(`Unknown command '${command}'.`);
+    return `FOLDER=${folder} tox -c ./test/${folder}/tox.ini -e ${command}`;
+}
+
+function sectionExistsInToxIni(command: string, folder: string): boolean {
+    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 {
+    if (!sectionExistsInToxIni(command, folder)) {
+        console.log(`No section for ${command} in tox.ini for folder ${folder}. Skipping...`);
+        return;
+    }
+    execSync(getCommand(command, folder), { stdio: "inherit" });
+}
+
+foldersToProcess.forEach((folder) => {
+    try {
+        if (commandToRun === "all") {
+            for (const key of validCommands) {
+                console.log(`Running ${key} for folder ${folder}...`);
+                myExecSync(key, folder);
+            }
+        } else if (getCommand(commandToRun, folder)) {
+            console.log(`Running ${commandToRun} for folder ${folder}...`);
+            myExecSync(commandToRun, folder);
+        } else {
+            console.error(`Error: Unknown command '${commandToRun}'.`);
+            process.exit(1);
+        }
+    } catch (error) {
+        console.error((error as Error).message);
+        console.error(`Error executing command for folder ${folder}: ${(error as Error).message}`);
+        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);
+});