@azure-tools/typespec-python 0.24.3 → 0.25.0

package/scripts/run-python3.cjs

@@ -0,0 +1,22 @@
+// 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: "node run-python3.cjs script.py"
+
+const cp = require("child_process");
+const extension = require("./system-requirements.cjs");
+
+async function runPython3(scriptName, ...args) {
+    const command = await extension.patchPythonPath(["python", scriptName, ...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());
+    process.exit(1);
+  });

package/scripts/run_tsp.py

@@ -0,0 +1,40 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+import sys
+import venv
+import logging
+from pathlib import Path
+from venvtools import python_run
+
+_ROOT_DIR = Path(__file__).parent.parent
+
+_LOGGER = logging.getLogger(__name__)
+
+if __name__ == "__main__":
+    venv_path = _ROOT_DIR / "venv"
+    venv_prexists = venv_path.exists()
+
+    assert venv_prexists  # Otherwise install was not done
+
+    env_builder = venv.EnvBuilder(with_pip=True)
+    venv_context = env_builder.ensure_directories(venv_path)
+
+    if "--debug" in sys.argv or "--debug=true" in sys.argv:
+        try:
+            import debugpy  # pylint: disable=import-outside-toplevel
+        except ImportError:
+            raise SystemExit("Please pip install ptvsd in order to use VSCode debugging")
+
+        # 5678 is the default attach port in the VS Code debug configurations
+        debugpy.listen(("localhost", 5678))
+        debugpy.wait_for_client()
+        breakpoint()  # pylint: disable=undefined-variable
+
+    # run m2r
+    python_run(venv_context, "generator.pygen.m2r", command=sys.argv[1:])
+    python_run(venv_context, "generator.pygen.preprocess.__init__", command=sys.argv[1:])
+    python_run(venv_context, "generator.pygen.codegen.__init__", command=sys.argv[1:])
+    python_run(venv_context, "generator.pygen.black", command=sys.argv[1:])

package/scripts/system-requirements.cjs

@@ -0,0 +1,180 @@
+const semver = require("semver");
+const child_process = require("child_process");
+
+/*
+ * Copied from @autorest/system-requirements
+ */
+
+const PythonRequirement = "python";
+const PRINT_PYTHON_VERSION_SCRIPT = "import sys; print('.'.join(map(str, sys.version_info[:3])))";
+
+
+function execute(command, cmdlineargs, options = {}) {
+    return new Promise((resolve, reject) => {
+    const cp = child_process.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,
+        }),
+    );
+    });
+};
+
+function versionIsSatisfied(version, requirement) {
+    const cleanedVersion = semver.coerce(version);
+  if (!cleanedVersion) {
+    throw new Error(`Invalid version ${version}.`);
+  }
+  return semver.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.
+ */
+function validateVersionRequirement(resolution, actualVersion, requirement) {
+    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,
+        };
+      }
+};
+
+async function tryPython(requirement, command, additionalArgs = []) {
+    const resolution = {
+        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.
+ */
+function getExecutablePath(requirement) {
+    return requirement.environmentVariable && process.env[requirement.environmentVariable];
+}
+
+function createPythonErrorMessage(requirement, errors) {
+    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"),
+    };
+};
+
+async function resolvePythonRequirement(requirement) {
+    const path = getExecutablePath(requirement) ?? process.env["AUTOREST_PYTHON_EXE"];
+    if (path) {
+        return await tryPython(requirement, path);
+    }
+
+    const errors = [];
+    // 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
+ */
+async function patchPythonPath(command, requirement) {
+    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];
+};
+module.exports.patchPythonPath = patchPythonPath;

package/scripts/venvtools.py

@@ -0,0 +1,81 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+from contextlib import contextmanager
+import tempfile
+import subprocess
+import venv
+import sys
+from pathlib import Path
+
+
+_ROOT_DIR = Path(__file__).parent.parent
+
+
+class ExtendedEnvBuilder(venv.EnvBuilder):
+    """An extended env builder which saves the context, to have access
+    easily to bin path and such.
+    """
+
+    def __init__(self, *args, **kwargs):
+        self.context = None
+        if sys.version_info < (3, 9, 0):
+            # Not supported on Python 3.8, and we don't need it
+            kwargs.pop("upgrade_deps", None)
+        super().__init__(*args, **kwargs)
+
+    def ensure_directories(self, env_dir):
+        self.context = super(ExtendedEnvBuilder, self).ensure_directories(env_dir)
+        return self.context
+
+
+def create(
+    env_dir, system_site_packages=False, clear=False, symlinks=False, with_pip=False, prompt=None, upgrade_deps=False
+):
+    """Create a virtual environment in a directory."""
+    builder = ExtendedEnvBuilder(
+        system_site_packages=system_site_packages,
+        clear=clear,
+        symlinks=symlinks,
+        with_pip=with_pip,
+        prompt=prompt,
+        upgrade_deps=upgrade_deps,
+    )
+    builder.create(env_dir)
+    return builder.context
+
+
+@contextmanager
+def create_venv_with_package(packages):
+    """Create a venv with these packages in a temp dir and yielf the env.
+
+    packages should be an iterable of pip version instructio (e.g. package~=1.2.3)
+    """
+    with tempfile.TemporaryDirectory() as tempdir:
+        myenv = create(tempdir, with_pip=True, upgrade_deps=True)
+        pip_call = [
+            myenv.env_exe,
+            "-m",
+            "pip",
+            "install",
+        ]
+        subprocess.check_call(pip_call + ["-U", "pip"])
+        if packages:
+            subprocess.check_call(pip_call + packages)
+        yield myenv
+
+
+def python_run(venv_context, module, command=None, *, additional_dir="."):
+    try:
+        cmd_line = [venv_context.env_exe, "-m", module] + (command if command else [])
+        print("Executing: {}".format(" ".join(cmd_line)))
+        subprocess.run(
+            cmd_line,
+            cwd=_ROOT_DIR / additional_dir,
+            check=True,
+        )
+    except subprocess.CalledProcessError as err:
+        print(err)
+        sys.exit(1)