mirror gitea.com/actions/setup-python@v5

src/cache-distributions/cache-distributor.ts

@@ -0,0 +1,71 @@
+import * as cache from '@actions/cache';
+import * as core from '@actions/core';
+import {CACHE_DEPENDENCY_BACKUP_PATH} from './constants';
+
+export enum State {
+  STATE_CACHE_PRIMARY_KEY = 'cache-primary-key',
+  CACHE_MATCHED_KEY = 'cache-matched-key',
+  CACHE_PATHS = 'cache-paths'
+}
+
+abstract class CacheDistributor {
+  protected CACHE_KEY_PREFIX = 'setup-python';
+  constructor(
+    protected packageManager: string,
+    protected cacheDependencyPath: string
+  ) {}
+
+  protected abstract getCacheGlobalDirectories(): Promise<string[]>;
+  protected abstract computeKeys(): Promise<{
+    primaryKey: string;
+    restoreKey: string[] | undefined;
+  }>;
+  protected async handleLoadedCache() {}
+
+  public async restoreCache() {
+    const {primaryKey, restoreKey} = await this.computeKeys();
+    if (primaryKey.endsWith('-')) {
+      const file =
+        this.packageManager === 'pip'
+          ? `${this.cacheDependencyPath
+              .split('\n')
+              .join(',')} or ${CACHE_DEPENDENCY_BACKUP_PATH}`
+          : this.cacheDependencyPath.split('\n').join(',');
+      throw new Error(
+        `No file in ${process.cwd()} matched to [${file}], make sure you have checked out the target repository`
+      );
+    }
+
+    const cachePath = await this.getCacheGlobalDirectories();
+
+    core.saveState(State.CACHE_PATHS, cachePath);
+
+    let matchedKey: string | undefined;
+    try {
+      matchedKey = await cache.restoreCache(cachePath, primaryKey, restoreKey);
+    } catch (err) {
+      const message = (err as Error).message;
+      core.info(`[warning]${message}`);
+      core.setOutput('cache-hit', false);
+      return;
+    }
+
+    core.saveState(State.STATE_CACHE_PRIMARY_KEY, primaryKey);
+
+    await this.handleLoadedCache();
+
+    this.handleMatchResult(matchedKey, primaryKey);
+  }
+
+  public handleMatchResult(matchedKey: string | undefined, primaryKey: string) {
+    if (matchedKey) {
+      core.saveState(State.CACHE_MATCHED_KEY, matchedKey);
+      core.info(`Cache restored from key: ${matchedKey}`);
+    } else {
+      core.info(`${this.packageManager} cache is not found`);
+    }
+    core.setOutput('cache-hit', matchedKey === primaryKey);
+  }
+}
+
+export default CacheDistributor;

src/cache-distributions/cache-factory.ts

@@ -0,0 +1,26 @@
+import PipCache from './pip-cache';
+import PipenvCache from './pipenv-cache';
+import PoetryCache from './poetry-cache';
+
+export enum PackageManagers {
+  Pip = 'pip',
+  Pipenv = 'pipenv',
+  Poetry = 'poetry'
+}
+
+export function getCacheDistributor(
+  packageManager: string,
+  pythonVersion: string,
+  cacheDependencyPath: string | undefined
+) {
+  switch (packageManager) {
+    case PackageManagers.Pip:
+      return new PipCache(pythonVersion, cacheDependencyPath);
+    case PackageManagers.Pipenv:
+      return new PipenvCache(pythonVersion, cacheDependencyPath);
+    case PackageManagers.Poetry:
+      return new PoetryCache(pythonVersion, cacheDependencyPath);
+    default:
+      throw new Error(`Caching for '${packageManager}' is not supported`);
+  }
+}

src/cache-distributions/constants.ts

@@ -0,0 +1 @@
+export const CACHE_DEPENDENCY_BACKUP_PATH = '**/pyproject.toml';

src/cache-distributions/pip-cache.ts

@@ -0,0 +1,84 @@
+import * as glob from '@actions/glob';
+import * as core from '@actions/core';
+import * as exec from '@actions/exec';
+import * as child_process from 'child_process';
+import utils from 'util';
+import * as path from 'path';
+import os from 'os';
+
+import CacheDistributor from './cache-distributor';
+import {getLinuxInfo, IS_LINUX, IS_WINDOWS} from '../utils';
+import {CACHE_DEPENDENCY_BACKUP_PATH} from './constants';
+
+class PipCache extends CacheDistributor {
+  private cacheDependencyBackupPath: string = CACHE_DEPENDENCY_BACKUP_PATH;
+
+  constructor(
+    private pythonVersion: string,
+    cacheDependencyPath = '**/requirements.txt'
+  ) {
+    super('pip', cacheDependencyPath);
+  }
+
+  protected async getCacheGlobalDirectories() {
+    let exitCode = 1;
+    let stdout = '';
+    let stderr = '';
+
+    // Add temporary fix for Windows
+    // On windows it is necessary to execute through an exec
+    // because the getExecOutput gives a non zero code or writes to stderr for pip 22.0.2,
+    // or spawn must be started with the shell option enabled for getExecOutput
+    // Related issue: https://github.com/actions/setup-python/issues/328
+    if (IS_WINDOWS) {
+      const execPromisify = utils.promisify(child_process.exec);
+      ({stdout: stdout, stderr: stderr} = await execPromisify('pip cache dir'));
+    } else {
+      ({
+        stdout: stdout,
+        stderr: stderr,
+        exitCode: exitCode
+      } = await exec.getExecOutput('pip cache dir'));
+    }
+
+    if (exitCode && stderr) {
+      throw new Error(
+        `Could not get cache folder path for pip package manager`
+      );
+    }
+
+    let resolvedPath = stdout.trim();
+
+    if (resolvedPath.includes('~')) {
+      resolvedPath = path.join(os.homedir(), resolvedPath.slice(1));
+    }
+
+    core.debug(`global cache directory path is ${resolvedPath}`);
+
+    return [resolvedPath];
+  }
+
+  protected async computeKeys() {
+    const hash =
+      (await glob.hashFiles(this.cacheDependencyPath)) ||
+      (await glob.hashFiles(this.cacheDependencyBackupPath));
+    let primaryKey = '';
+    let restoreKey = '';
+
+    if (IS_LINUX) {
+      const osInfo = await getLinuxInfo();
+      primaryKey = `${this.CACHE_KEY_PREFIX}-${process.env['RUNNER_OS']}-${process.arch}-${osInfo.osVersion}-${osInfo.osName}-python-${this.pythonVersion}-${this.packageManager}-${hash}`;
+      restoreKey = `${this.CACHE_KEY_PREFIX}-${process.env['RUNNER_OS']}-${process.arch}-${osInfo.osVersion}-${osInfo.osName}-python-${this.pythonVersion}-${this.packageManager}`;
+    } else {
+      primaryKey = `${this.CACHE_KEY_PREFIX}-${process.env['RUNNER_OS']}-${process.arch}-python-${this.pythonVersion}-${this.packageManager}-${hash}`;
+      restoreKey = `${this.CACHE_KEY_PREFIX}-${process.env['RUNNER_OS']}-${process.arch}-python-${this.pythonVersion}-${this.packageManager}`;
+    }
+
+    return {
+      primaryKey,
+      restoreKey: [restoreKey]
+    };
+  }
+}
+
+export default PipCache;

src/cache-distributions/pipenv-cache.ts

@@ -0,0 +1,44 @@
+import * as glob from '@actions/glob';
+import * as os from 'os';
+import * as path from 'path';
+import * as core from '@actions/core';
+
+import CacheDistributor from './cache-distributor';
+
+class PipenvCache extends CacheDistributor {
+  constructor(
+    private pythonVersion: string,
+    protected patterns: string = '**/Pipfile.lock'
+  ) {
+    super('pipenv', patterns);
+  }
+
+  protected async getCacheGlobalDirectories() {
+    let virtualEnvRelativePath;
+
+    // Default virtualenv directories are hardcoded,
+    // because pipenv is not preinstalled on hosted images and virtualenv is not created:
+    // https://github.com/pypa/pipenv/blob/1daaa0de9a0b00d386c6baeb809d8d4ee6795cfd/pipenv/utils.py#L1990-L2002
+    if (process.platform === 'win32') {
+      virtualEnvRelativePath = '.virtualenvs';
+    } else {
+      virtualEnvRelativePath = '.local/share/virtualenvs';
+    }
+    const resolvedPath = path.join(os.homedir(), virtualEnvRelativePath);
+    core.debug(`global cache directory path is ${resolvedPath}`);
+
+    return [resolvedPath];
+  }
+
+  protected async computeKeys() {
+    const hash = await glob.hashFiles(this.patterns);
+    const primaryKey = `${this.CACHE_KEY_PREFIX}-${process.env['RUNNER_OS']}-${process.arch}-python-${this.pythonVersion}-${this.packageManager}-${hash}`;
+    const restoreKey = undefined;
+    return {
+      primaryKey,
+      restoreKey
+    };
+  }
+}
+
+export default PipenvCache;

src/cache-distributions/poetry-cache.ts

@@ -0,0 +1,118 @@
+import * as glob from '@actions/glob';
+import * as io from '@actions/io';
+import * as path from 'path';
+import * as exec from '@actions/exec';
+import * as core from '@actions/core';
+
+import CacheDistributor from './cache-distributor';
+import {logWarning} from '../utils';
+
+class PoetryCache extends CacheDistributor {
+  constructor(
+    private pythonVersion: string,
+    protected patterns: string = '**/poetry.lock',
+    protected poetryProjects: Set<string> = new Set<string>()
+  ) {
+    super('poetry', patterns);
+  }
+
+  protected async getCacheGlobalDirectories() {
+    // Same virtualenvs path may appear for different projects, hence we use a Set
+    const paths = new Set<string>();
+    const globber = await glob.create(this.patterns);
+
+    for await (const file of globber.globGenerator()) {
+      const basedir = path.dirname(file);
+      core.debug(`Processing Poetry project at ${basedir}`);
+      this.poetryProjects.add(basedir);
+
+      const poetryConfig = await this.getPoetryConfiguration(basedir);
+
+      const cacheDir = poetryConfig['cache-dir'];
+      const virtualenvsPath = poetryConfig['virtualenvs.path'].replace(
+        '{cache-dir}',
+        cacheDir
+      );
+
+      paths.add(virtualenvsPath);
+
+      if (poetryConfig['virtualenvs.in-project']) {
+        paths.add(path.join(basedir, '.venv'));
+      }
+    }
+
+    return [...paths];
+  }
+
+  protected async computeKeys() {
+    const hash = await glob.hashFiles(this.patterns);
+    // "v2" is here to invalidate old caches of this cache distributor, which were created broken:
+    const primaryKey = `${this.CACHE_KEY_PREFIX}-${process.env['RUNNER_OS']}-${process.arch}-python-${this.pythonVersion}-${this.packageManager}-v2-${hash}`;
+    const restoreKey = undefined;
+    return {
+      primaryKey,
+      restoreKey
+    };
+  }
+
+  protected async handleLoadedCache() {
+    await super.handleLoadedCache();
+
+    // After the cache is loaded -- make sure virtualenvs use the correct Python version (the one that we have just installed).
+    // This will handle invalid caches, recreating virtualenvs if necessary.
+
+    const pythonLocation = await io.which('python');
+    if (pythonLocation) {
+      core.debug(`pythonLocation is ${pythonLocation}`);
+    } else {
+      logWarning('python binaries were not found in PATH');
+      return;
+    }
+
+    for (const poetryProject of this.poetryProjects) {
+      const {exitCode, stderr} = await exec.getExecOutput(
+        'poetry',
+        ['env', 'use', pythonLocation],
+        {ignoreReturnCode: true, cwd: poetryProject}
+      );
+
+      if (exitCode) {
+        logWarning(stderr);
+      }
+    }
+  }
+
+  private async getPoetryConfiguration(basedir: string) {
+    const {stdout, stderr, exitCode} = await exec.getExecOutput(
+      'poetry',
+      ['config', '--list'],
+      {cwd: basedir}
+    );
+
+    if (exitCode && stderr) {
+      throw new Error(
+        'Could not get cache folder path for poetry package manager'
+      );
+    }
+
+    const lines = stdout.trim().split('\n');
+
+    const config: any = {};
+
+    for (let line of lines) {
+      line = line.replace(/#.*$/gm, '');
+
+      const [key, value] = line.split('=').map(part => part.trim());
+
+      config[key] = JSON.parse(value);
+    }
+
+    return config as {
+      'cache-dir': string;
+      'virtualenvs.in-project': boolean;
+      'virtualenvs.path': string;
+    };
+  }
+}
+
+export default PoetryCache;

src/cache-save.ts

@@ -0,0 +1,86 @@
+import * as core from '@actions/core';
+import * as cache from '@actions/cache';
+
+import fs from 'fs';
+import {State} from './cache-distributions/cache-distributor';
+
+// Added early exit to resolve issue with slow post action step:
+// - https://github.com/actions/setup-node/issues/878
+// https://github.com/actions/cache/pull/1217
+export async function run(earlyExit?: boolean) {
+  try {
+    const cache = core.getInput('cache');
+    if (cache) {
+      await saveCache(cache);
+
+      if (earlyExit) {
+        process.exit(0);
+      }
+    }
+  } catch (error) {
+    const err = error as Error;
+    core.setFailed(err.message);
+  }
+}
+
+async function saveCache(packageManager: string) {
+  const cachePathState = core.getState(State.CACHE_PATHS);
+
+  if (!cachePathState) {
+    core.warning(
+      'Cache paths are empty. Please check the previous logs and make sure that the python version is specified'
+    );
+    return;
+  }
+
+  const cachePaths = JSON.parse(cachePathState) as string[];
+
+  core.debug(`paths for caching are ${cachePaths.join(', ')}`);
+
+  if (!isCacheDirectoryExists(cachePaths)) {
+    throw new Error(
+      `Cache folder path is retrieved for ${packageManager} but doesn't exist on disk: ${cachePaths.join(
+        ', '
+      )}. This likely indicates that there are no dependencies to cache. Consider removing the cache step if it is not needed.`
+    );
+  }
+
+  const primaryKey = core.getState(State.STATE_CACHE_PRIMARY_KEY);
+  const matchedKey = core.getState(State.CACHE_MATCHED_KEY);
+
+  if (!primaryKey) {
+    core.warning('Error retrieving key from state.');
+    return;
+  } else if (matchedKey === primaryKey) {
+    // no change in target directories
+    core.info(
+      `Cache hit occurred on the primary key ${primaryKey}, not saving cache.`
+    );
+    return;
+  }
+
+  let cacheId = 0;
+
+  try {
+    cacheId = await cache.saveCache(cachePaths, primaryKey);
+  } catch (err) {
+    const message = (err as Error).message;
+    core.info(`[warning]${message}`);
+    return;
+  }
+
+  if (cacheId == -1) {
+    return;
+  }
+  core.info(`Cache saved with the key: ${primaryKey}`);
+}
+
+function isCacheDirectoryExists(cacheDirectory: string[]) {
+  const result = cacheDirectory.reduce((previousValue, currentValue) => {
+    return previousValue || fs.existsSync(currentValue);
+  }, false);
+
+  return result;
+}
+
+run(true);

src/find-graalpy.ts

@@ -0,0 +1,146 @@
+import * as path from 'path';
+import * as graalpyInstall from './install-graalpy';
+import {
+  IS_WINDOWS,
+  validateVersion,
+  IGraalPyManifestRelease,
+  getBinaryDirectory
+} from './utils';
+
+import * as semver from 'semver';
+import * as core from '@actions/core';
+import * as tc from '@actions/tool-cache';
+
+export async function findGraalPyVersion(
+  versionSpec: string,
+  architecture: string,
+  updateEnvironment: boolean,
+  checkLatest: boolean,
+  allowPreReleases: boolean
+): Promise<string> {
+  let resolvedGraalPyVersion = '';
+  let installDir: string | null;
+  let releases: IGraalPyManifestRelease[] | undefined;
+
+  let graalpyVersionSpec = parseGraalPyVersion(versionSpec);
+
+  if (checkLatest) {
+    releases = await graalpyInstall.getAvailableGraalPyVersions();
+    if (releases && releases.length > 0) {
+      const releaseData = graalpyInstall.findRelease(
+        releases,
+        graalpyVersionSpec,
+        architecture,
+        false
+      );
+
+      if (releaseData) {
+        core.info(`Resolved as GraalPy ${releaseData.resolvedGraalPyVersion}`);
+        graalpyVersionSpec = releaseData.resolvedGraalPyVersion;
+      } else {
+        core.info(
+          `Failed to resolve GraalPy ${graalpyVersionSpec} from manifest`
+        );
+      }
+    }
+  }
+
+  ({installDir, resolvedGraalPyVersion} = findGraalPyToolCache(
+    graalpyVersionSpec,
+    architecture
+  ));
+
+  if (!installDir) {
+    ({installDir, resolvedGraalPyVersion} = await graalpyInstall.installGraalPy(
+      graalpyVersionSpec,
+      architecture,
+      allowPreReleases,
+      releases
+    ));
+  }
+
+  const pipDir = IS_WINDOWS ? 'Scripts' : 'bin';
+  const _binDir = path.join(installDir, pipDir);
+  const binaryExtension = IS_WINDOWS ? '.exe' : '';
+  const pythonPath = path.join(
+    IS_WINDOWS ? installDir : _binDir,
+    `python${binaryExtension}`
+  );
+  const pythonLocation = getBinaryDirectory(installDir);
+  if (updateEnvironment) {
+    core.exportVariable('pythonLocation', installDir);
+    // https://cmake.org/cmake/help/latest/module/FindPython.html#module:FindPython
+    core.exportVariable('Python_ROOT_DIR', installDir);
+    // https://cmake.org/cmake/help/latest/module/FindPython2.html#module:FindPython2
+    core.exportVariable('Python2_ROOT_DIR', installDir);
+    // https://cmake.org/cmake/help/latest/module/FindPython3.html#module:FindPython3
+    core.exportVariable('Python3_ROOT_DIR', installDir);
+    core.exportVariable('PKG_CONFIG_PATH', pythonLocation + '/lib/pkgconfig');
+    core.addPath(pythonLocation);
+    core.addPath(_binDir);
+  }
+  core.setOutput('python-version', 'graalpy' + resolvedGraalPyVersion);
+  core.setOutput('python-path', pythonPath);
+
+  return resolvedGraalPyVersion;
+}
+
+export function findGraalPyToolCache(
+  graalpyVersion: string,
+  architecture: string
+) {
+  let resolvedGraalPyVersion = '';
+  let installDir: string | null = tc.find(
+    'GraalPy',
+    graalpyVersion,
+    architecture
+  );
+
+  if (installDir) {
+    // 'tc.find' finds tool based on Python version but we also need to check
+    // whether GraalPy version satisfies requested version.
+    resolvedGraalPyVersion = path.basename(path.dirname(installDir));
+
+    const isGraalPyVersionSatisfies = semver.satisfies(
+      resolvedGraalPyVersion,
+      graalpyVersion
+    );
+    if (!isGraalPyVersionSatisfies) {
+      installDir = null;
+      resolvedGraalPyVersion = '';
+    }
+  }
+
+  if (!installDir) {
+    core.info(
+      `GraalPy version ${graalpyVersion} was not found in the local cache`
+    );
+  }
+
+  return {installDir, resolvedGraalPyVersion};
+}
+
+export function parseGraalPyVersion(versionSpec: string): string {
+  const versions = versionSpec.split('-').filter(item => !!item);
+
+  if (/^(graalpy)(.+)/.test(versions[0])) {
+    const version = versions[0].replace('graalpy', '');
+    versions.splice(0, 1, 'graalpy', version);
+  }
+
+  if (versions.length < 2 || versions[0] != 'graalpy') {
+    throw new Error(
+      "Invalid 'version' property for GraalPy. GraalPy version should be specified as 'graalpy<python-version>' or 'graalpy-<python-version>'. See README for examples and documentation."
+    );
+  }
+
+  const pythonVersion = versions[1];
+
+  if (!validateVersion(pythonVersion)) {
+    throw new Error(
+      "Invalid 'version' property for GraalPy. GraalPy versions should satisfy SemVer notation. See README for examples and documentation."
+    );
+  }
+
+  return pythonVersion;
+}

src/find-pypy.ts

@@ -0,0 +1,191 @@
+import * as path from 'path';
+import * as pypyInstall from './install-pypy';
+import {
+  IS_WINDOWS,
+  WINDOWS_ARCHS,
+  validateVersion,
+  getPyPyVersionFromPath,
+  readExactPyPyVersionFile,
+  validatePythonVersionFormatForPyPy,
+  IPyPyManifestRelease,
+  getBinaryDirectory
+} from './utils';
+
+import * as semver from 'semver';
+import * as core from '@actions/core';
+import * as tc from '@actions/tool-cache';
+
+interface IPyPyVersionSpec {
+  pypyVersion: string;
+  pythonVersion: string;
+}
+
+export async function findPyPyVersion(
+  versionSpec: string,
+  architecture: string,
+  updateEnvironment: boolean,
+  checkLatest: boolean,
+  allowPreReleases: boolean
+): Promise<{resolvedPyPyVersion: string; resolvedPythonVersion: string}> {
+  let resolvedPyPyVersion = '';
+  let resolvedPythonVersion = '';
+  let installDir: string | null;
+  let releases: IPyPyManifestRelease[] | undefined;
+
+  const pypyVersionSpec = parsePyPyVersion(versionSpec);
+
+  if (checkLatest) {
+    releases = await pypyInstall.getAvailablePyPyVersions();
+    if (releases && releases.length > 0) {
+      const releaseData = pypyInstall.findRelease(
+        releases,
+        pypyVersionSpec.pythonVersion,
+        pypyVersionSpec.pypyVersion,
+        architecture,
+        false
+      );
+
+      if (releaseData) {
+        core.info(
+          `Resolved as PyPy ${releaseData.resolvedPyPyVersion} with Python (${releaseData.resolvedPythonVersion})`
+        );
+        pypyVersionSpec.pythonVersion = releaseData.resolvedPythonVersion;
+        pypyVersionSpec.pypyVersion = releaseData.resolvedPyPyVersion;
+      } else {
+        core.info(
+          `Failed to resolve PyPy ${pypyVersionSpec.pypyVersion} with Python (${pypyVersionSpec.pythonVersion}) from manifest`
+        );
+      }
+    }
+  }
+
+  ({installDir, resolvedPythonVersion, resolvedPyPyVersion} = findPyPyToolCache(
+    pypyVersionSpec.pythonVersion,
+    pypyVersionSpec.pypyVersion,
+    architecture
+  ));
+
+  if (!installDir) {
+    ({installDir, resolvedPythonVersion, resolvedPyPyVersion} =
+      await pypyInstall.installPyPy(
+        pypyVersionSpec.pypyVersion,
+        pypyVersionSpec.pythonVersion,
+        architecture,
+        allowPreReleases,
+        releases
+      ));
+  }
+
+  const pipDir = IS_WINDOWS ? 'Scripts' : 'bin';
+  const _binDir = path.join(installDir, pipDir);
+  const binaryExtension = IS_WINDOWS ? '.exe' : '';
+  const pythonPath = path.join(
+    IS_WINDOWS ? installDir : _binDir,
+    `python${binaryExtension}`
+  );
+  const pythonLocation = getBinaryDirectory(installDir);
+  if (updateEnvironment) {
+    core.exportVariable('pythonLocation', installDir);
+    // https://cmake.org/cmake/help/latest/module/FindPython.html#module:FindPython
+    core.exportVariable('Python_ROOT_DIR', installDir);
+    // https://cmake.org/cmake/help/latest/module/FindPython2.html#module:FindPython2
+    core.exportVariable('Python2_ROOT_DIR', installDir);
+    // https://cmake.org/cmake/help/latest/module/FindPython3.html#module:FindPython3
+    core.exportVariable('Python3_ROOT_DIR', installDir);
+    core.exportVariable('PKG_CONFIG_PATH', pythonLocation + '/lib/pkgconfig');
+    core.addPath(pythonLocation);
+    core.addPath(_binDir);
+  }
+  core.setOutput('python-version', 'pypy' + resolvedPyPyVersion);
+  core.setOutput('python-path', pythonPath);
+
+  return {resolvedPyPyVersion, resolvedPythonVersion};
+}
+
+export function findPyPyToolCache(
+  pythonVersion: string,
+  pypyVersion: string,
+  architecture: string
+) {
+  let resolvedPyPyVersion = '';
+  let resolvedPythonVersion = '';
+  let installDir: string | null = IS_WINDOWS
+    ? findPyPyInstallDirForWindows(pythonVersion)
+    : tc.find('PyPy', pythonVersion, architecture);
+
+  if (installDir) {
+    // 'tc.find' finds tool based on Python version but we also need to check
+    // whether PyPy version satisfies requested version.
+    resolvedPythonVersion = getPyPyVersionFromPath(installDir);
+    resolvedPyPyVersion = readExactPyPyVersionFile(installDir);
+
+    const isPyPyVersionSatisfies = semver.satisfies(
+      resolvedPyPyVersion,
+      pypyVersion
+    );
+    if (!isPyPyVersionSatisfies) {
+      installDir = null;
+      resolvedPyPyVersion = '';
+      resolvedPythonVersion = '';
+    }
+  }
+
+  if (!installDir) {
+    core.info(
+      `PyPy version ${pythonVersion} (${pypyVersion}) was not found in the local cache`
+    );
+  }
+
+  return {installDir, resolvedPythonVersion, resolvedPyPyVersion};
+}
+
+export function parsePyPyVersion(versionSpec: string): IPyPyVersionSpec {
+  const versions = versionSpec.split('-').filter(item => !!item);
+
+  if (/^(pypy)(.+)/.test(versions[0])) {
+    const pythonVersion = versions[0].replace('pypy', '');
+    versions.splice(0, 1, 'pypy', pythonVersion);
+  }
+
+  if (versions.length < 2 || versions[0] != 'pypy') {
+    throw new Error(
+      "Invalid 'version' property for PyPy. PyPy version should be specified as 'pypy<python-version>' or 'pypy-<python-version>'. See README for examples and documentation."
+    );
+  }
+
+  const pythonVersion = versions[1];
+  let pypyVersion: string;
+  if (versions.length > 2) {
+    pypyVersion = pypyInstall.pypyVersionToSemantic(versions[2]);
+  } else {
+    pypyVersion = 'x';
+  }
+
+  if (!validateVersion(pythonVersion) || !validateVersion(pypyVersion)) {
+    throw new Error(
+      "Invalid 'version' property for PyPy. Both Python version and PyPy versions should satisfy SemVer notation. See README for examples and documentation."
+    );
+  }
+
+  if (!validatePythonVersionFormatForPyPy(pythonVersion)) {
+    throw new Error(
+      "Invalid format of Python version for PyPy. Python version should be specified in format 'x.y'. See README for examples and documentation."
+    );
+  }
+
+  return {
+    pypyVersion: pypyVersion,
+    pythonVersion: pythonVersion
+  };
+}
+
+export function findPyPyInstallDirForWindows(pythonVersion: string): string {
+  let installDir = '';
+
+  WINDOWS_ARCHS.forEach(
+    architecture =>
+      (installDir = installDir || tc.find('PyPy', pythonVersion, architecture))
+  );
+
+  return installDir;
+}

src/find-python.ts

@@ -0,0 +1,245 @@
+import * as os from 'os';
+import * as path from 'path';
+import {IS_WINDOWS, IS_LINUX, getOSInfo} from './utils';
+
+import * as semver from 'semver';
+
+import * as installer from './install-python';
+
+import * as core from '@actions/core';
+import * as tc from '@actions/tool-cache';
+
+// Python has "scripts" or "bin" directories where command-line tools that come with packages are installed.
+// This is where pip is, along with anything that pip installs.
+// There is a separate directory for `pip install --user`.
+//
+// For reference, these directories are as follows:
+//   macOS / Linux:
+//      <sys.prefix>/bin (by default /usr/local/bin, but not on hosted agents -- see the `else`)
+//      (--user) ~/.local/bin
+//   Windows:
+//      <Python installation dir>\Scripts
+//      (--user) %APPDATA%\Python\PythonXY\Scripts
+// See https://docs.python.org/3/library/sysconfig.html
+
+function binDir(installDir: string): string {
+  if (IS_WINDOWS) {
+    return path.join(installDir, 'Scripts');
+  } else {
+    return path.join(installDir, 'bin');
+  }
+}
+
+export async function useCpythonVersion(
+  version: string,
+  architecture: string,
+  updateEnvironment: boolean,
+  checkLatest: boolean,
+  allowPreReleases: boolean,
+  freethreaded: boolean
+): Promise<InstalledVersion> {
+  let manifest: tc.IToolRelease[] | null = null;
+  const {version: desugaredVersionSpec, freethreaded: versionFreethreaded} =
+    desugarVersion(version);
+  let semanticVersionSpec = pythonVersionToSemantic(
+    desugaredVersionSpec,
+    allowPreReleases
+  );
+  if (versionFreethreaded) {
+    // Use the freethreaded version if it was specified in the input, e.g., 3.13t
+    freethreaded = true;
+  }
+  core.debug(`Semantic version spec of ${version} is ${semanticVersionSpec}`);
+
+  if (freethreaded) {
+    // Free threaded versions use an architecture suffix like `x64-freethreaded`
+    core.debug(`Using freethreaded version of ${semanticVersionSpec}`);
+    architecture += '-freethreaded';
+  }
+
+  if (checkLatest) {
+    manifest = await installer.getManifest();
+    const resolvedVersion = (
+      await installer.findReleaseFromManifest(
+        semanticVersionSpec,
+        architecture,
+        manifest
+      )
+    )?.version;
+
+    if (resolvedVersion) {
+      semanticVersionSpec = resolvedVersion;
+      core.info(`Resolved as '${semanticVersionSpec}'`);
+    } else {
+      core.info(
+        `Failed to resolve version ${semanticVersionSpec} from manifest`
+      );
+    }
+  }
+
+  let installDir: string | null = tc.find(
+    'Python',
+    semanticVersionSpec,
+    architecture
+  );
+  if (!installDir) {
+    core.info(
+      `Version ${semanticVersionSpec} was not found in the local cache`
+    );
+    const foundRelease = await installer.findReleaseFromManifest(
+      semanticVersionSpec,
+      architecture,
+      manifest
+    );
+
+    if (foundRelease && foundRelease.files && foundRelease.files.length > 0) {
+      core.info(`Version ${semanticVersionSpec} is available for downloading`);
+      await installer.installCpythonFromRelease(foundRelease);
+
+      installDir = tc.find('Python', semanticVersionSpec, architecture);
+    }
+  }
+
+  if (!installDir) {
+    const osInfo = await getOSInfo();
+    const msg = [
+      `The version '${version}' with architecture '${architecture}' was not found for ${
+        osInfo
+          ? `${osInfo.osName} ${osInfo.osVersion}`
+          : 'this operating system'
+      }.`
+    ];
+    if (freethreaded) {
+      msg.push(
+        `Free threaded versions are only available for Python 3.13.0 and later.`
+      );
+    }
+    msg.push(
+      `The list of all available versions can be found here: ${installer.MANIFEST_URL}`
+    );
+    throw new Error(msg.join(os.EOL));
+  }
+
+  const _binDir = binDir(installDir);
+  const binaryExtension = IS_WINDOWS ? '.exe' : '';
+  const pythonPath = path.join(
+    IS_WINDOWS ? installDir : _binDir,
+    `python${binaryExtension}`
+  );
+  if (updateEnvironment) {
+    core.exportVariable('pythonLocation', installDir);
+    core.exportVariable('PKG_CONFIG_PATH', installDir + '/lib/pkgconfig');
+    core.exportVariable('pythonLocation', installDir);
+    // https://cmake.org/cmake/help/latest/module/FindPython.html#module:FindPython
+    core.exportVariable('Python_ROOT_DIR', installDir);
+    // https://cmake.org/cmake/help/latest/module/FindPython2.html#module:FindPython2
+    core.exportVariable('Python2_ROOT_DIR', installDir);
+    // https://cmake.org/cmake/help/latest/module/FindPython3.html#module:FindPython3
+    core.exportVariable('Python3_ROOT_DIR', installDir);
+    core.exportVariable('PKG_CONFIG_PATH', installDir + '/lib/pkgconfig');
+
+    if (IS_LINUX) {
+      const libPath = process.env.LD_LIBRARY_PATH
+        ? `:${process.env.LD_LIBRARY_PATH}`
+        : '';
+      const pyLibPath = path.join(installDir, 'lib');
+
+      if (!libPath.split(':').includes(pyLibPath)) {
+        core.exportVariable('LD_LIBRARY_PATH', pyLibPath + libPath);
+      }
+    }
+    core.addPath(installDir);
+    core.addPath(_binDir);
+
+    if (IS_WINDOWS) {
+      // Add --user directory
+      // `installDir` from tool cache should look like $RUNNER_TOOL_CACHE/Python/<semantic version>/x64/
+      // So if `findLocalTool` succeeded above, we must have a conformant `installDir`
+      const version = path.basename(path.dirname(installDir));
+      const major = semver.major(version);
+      const minor = semver.minor(version);
+
+      const userScriptsDir = path.join(
+        process.env['APPDATA'] || '',
+        'Python',
+        `Python${major}${minor}`,
+        'Scripts'
+      );
+      core.addPath(userScriptsDir);
+    }
+    // On Linux and macOS, pip will create the --user directory and add it to PATH as needed.
+  }
+
+  const installed = versionFromPath(installDir);
+  let pythonVersion = installed;
+  if (freethreaded) {
+    // Add the freethreaded suffix to the version (e.g., 3.13.1t)
+    pythonVersion += 't';
+  }
+  core.setOutput('python-version', pythonVersion);
+  core.setOutput('python-path', pythonPath);
+
+  return {impl: 'CPython', version: pythonVersion};
+}
+
+/* Desugar free threaded and dev versions */
+export function desugarVersion(versionSpec: string) {
+  const {version, freethreaded} = desugarFreeThreadedVersion(versionSpec);
+  return {version: desugarDevVersion(version), freethreaded};
+}
+
+/* Identify freethreaded versions like, 3.13t, 3.13.1t, 3.13t-dev.
+ * Returns the version without the `t` and the architectures suffix, if freethreaded */
+function desugarFreeThreadedVersion(versionSpec: string) {
+  const majorMinor = /^(\d+\.\d+(\.\d+)?)(t)$/;
+  if (majorMinor.test(versionSpec)) {
+    return {version: versionSpec.replace(majorMinor, '$1'), freethreaded: true};
+  }
+  const devVersion = /^(\d+\.\d+)(t)(-dev)$/;
+  if (devVersion.test(versionSpec)) {
+    return {
+      version: versionSpec.replace(devVersion, '$1$3'),
+      freethreaded: true
+    };
+  }
+  return {version: versionSpec, freethreaded: false};
+}
+
+/** Convert versions like `3.8-dev` to a version like `~3.8.0-0`. */
+function desugarDevVersion(versionSpec: string) {
+  const devVersion = /^(\d+)\.(\d+)-dev$/;
+  return versionSpec.replace(devVersion, '~$1.$2.0-0');
+}
+
+/** Extracts python version from install path from hosted tool cache as described in README.md */
+function versionFromPath(installDir: string) {
+  const parts = installDir.split(path.sep);
+  const idx = parts.findIndex(part => part === 'PyPy' || part === 'Python');
+
+  return parts[idx + 1] || '';
+}
+
+interface InstalledVersion {
+  impl: string;
+  version: string;
+}
+
+/**
+ * Python's prelease versions look like `3.7.0b2`.
+ * This is the one part of Python versioning that does not look like semantic versioning, which specifies `3.7.0-b2`.
+ * If the version spec contains prerelease versions, we need to convert them to the semantic version equivalent.
+ *
+ * For easier use of the action, we also map 'x.y' to allow pre-release before 'x.y.0' release if allowPreReleases is true
+ */
+export function pythonVersionToSemantic(
+  versionSpec: string,
+  allowPreReleases: boolean
+) {
+  const prereleaseVersion = /(\d+\.\d+\.\d+)((?:a|b|rc)\d*)/g;
+  const majorMinor = /^(\d+)\.(\d+)$/;
+  let result = versionSpec.replace(prereleaseVersion, '$1-$2');
+  if (allowPreReleases) {
+    result = result.replace(majorMinor, '~$1.$2.0-0');
+  }
+  return result;
+}

src/install-graalpy.ts

@@ -0,0 +1,264 @@
+import * as os from 'os';
+import * as path from 'path';
+import * as core from '@actions/core';
+import * as tc from '@actions/tool-cache';
+import * as semver from 'semver';
+import * as httpm from '@actions/http-client';
+import * as ifm from '@actions/http-client/lib/interfaces';
+import * as exec from '@actions/exec';
+
+import fs from 'fs';
+import * as http from 'http';
+
+import {
+  IS_WINDOWS,
+  IGraalPyManifestRelease,
+  createSymlinkInFolder,
+  isNightlyKeyword,
+  getBinaryDirectory,
+  getNextPageUrl
+} from './utils';
+
+const TOKEN = core.getInput('token');
+const AUTH = !TOKEN ? undefined : `token ${TOKEN}`;
+
+export async function installGraalPy(
+  graalpyVersion: string,
+  architecture: string,
+  allowPreReleases: boolean,
+  releases: IGraalPyManifestRelease[] | undefined
+) {
+  let downloadDir;
+
+  releases = releases ?? (await getAvailableGraalPyVersions());
+
+  if (!releases || !releases.length) {
+    throw new Error('No release was found in GraalPy version.json');
+  }
+
+  let releaseData = findRelease(releases, graalpyVersion, architecture, false);
+
+  if (allowPreReleases && (!releaseData || !releaseData.foundAsset)) {
+    // check for pre-release
+    core.info(
+      [
+        `Stable GraalPy version ${graalpyVersion} with arch ${architecture} not found`,
+        `Trying pre-release versions`
+      ].join(os.EOL)
+    );
+    releaseData = findRelease(releases, graalpyVersion, architecture, true);
+  }
+
+  if (!releaseData || !releaseData.foundAsset) {
+    throw new Error(
+      `GraalPy version ${graalpyVersion} with arch ${architecture} not found`
+    );
+  }
+
+  const {foundAsset, resolvedGraalPyVersion} = releaseData;
+  const downloadUrl = `${foundAsset.browser_download_url}`;
+
+  core.info(`Downloading GraalPy from "${downloadUrl}" ...`);
+
+  try {
+    const graalpyPath = await tc.downloadTool(downloadUrl, undefined, AUTH);
+
+    core.info('Extracting downloaded archive...');
+    downloadDir = await tc.extractTar(graalpyPath);
+
+    // root folder in archive can have unpredictable name so just take the first folder
+    // downloadDir is unique folder under TEMP and can't contain any other folders
+    const archiveName = fs.readdirSync(downloadDir)[0];
+
+    const toolDir = path.join(downloadDir, archiveName);
+    let installDir = toolDir;
+    if (!isNightlyKeyword(resolvedGraalPyVersion)) {
+      installDir = await tc.cacheDir(
+        toolDir,
+        'GraalPy',
+        resolvedGraalPyVersion,
+        architecture
+      );
+    }
+
+    const binaryPath = getBinaryDirectory(installDir);
+    await createGraalPySymlink(binaryPath, resolvedGraalPyVersion);
+    await installPip(binaryPath);
+
+    return {installDir, resolvedGraalPyVersion};
+  } catch (err) {
+    if (err instanceof Error) {
+      // Rate limit?
+      if (
+        err instanceof tc.HTTPError &&
+        (err.httpStatusCode === 403 || err.httpStatusCode === 429)
+      ) {
+        core.info(
+          `Received HTTP status code ${err.httpStatusCode}.  This usually indicates the rate limit has been exceeded`
+        );
+      } else {
+        core.info(err.message);
+      }
+      if (err.stack !== undefined) {
+        core.debug(err.stack);
+      }
+    }
+    throw err;
+  }
+}
+
+export async function getAvailableGraalPyVersions() {
+  const http: httpm.HttpClient = new httpm.HttpClient('tool-cache');
+
+  const headers: http.OutgoingHttpHeaders = {};
+  if (AUTH) {
+    headers.authorization = AUTH;
+  }
+
+  let url: string | null =
+    'https://api.github.com/repos/oracle/graalpython/releases';
+  const result: IGraalPyManifestRelease[] = [];
+  do {
+    const response: ifm.TypedResponse<IGraalPyManifestRelease[]> =
+      await http.getJson(url, headers);
+    if (!response.result) {
+      throw new Error(
+        `Unable to retrieve the list of available GraalPy versions from '${url}'`
+      );
+    }
+    result.push(...response.result);
+    url = getNextPageUrl(response);
+  } while (url);
+
+  return result;
+}
+
+async function createGraalPySymlink(
+  graalpyBinaryPath: string,
+  graalpyVersion: string
+) {
+  const version = semver.coerce(graalpyVersion)!;
+  const pythonBinaryPostfix = semver.major(version);
+  const pythonMinor = semver.minor(version);
+  const graalpyMajorMinorBinaryPostfix = `${pythonBinaryPostfix}.${pythonMinor}`;
+  const binaryExtension = IS_WINDOWS ? '.exe' : '';
+
+  core.info('Creating symlinks...');
+  createSymlinkInFolder(
+    graalpyBinaryPath,
+    `graalpy${binaryExtension}`,
+    `python${pythonBinaryPostfix}${binaryExtension}`,
+    true
+  );
+
+  createSymlinkInFolder(
+    graalpyBinaryPath,
+    `graalpy${binaryExtension}`,
+    `python${binaryExtension}`,
+    true
+  );
+
+  createSymlinkInFolder(
+    graalpyBinaryPath,
+    `graalpy${binaryExtension}`,
+    `graalpy${graalpyMajorMinorBinaryPostfix}${binaryExtension}`,
+    true
+  );
+}
+
+async function installPip(pythonLocation: string) {
+  core.info(
+    "Installing pip (GraalPy doesn't update pip because it uses a patched version of pip)"
+  );
+  const pythonBinary = path.join(pythonLocation, 'python');
+  await exec.exec(`${pythonBinary} -m ensurepip --default-pip`);
+}
+
+export function graalPyTagToVersion(tag: string) {
+  const versionPattern = /.*-(\d+\.\d+\.\d+(?:\.\d+)?)((?:a|b|rc))?(\d*)?/;
+  const match = tag.match(versionPattern);
+  if (match && match[2]) {
+    return `${match[1]}-${match[2]}.${match[3]}`;
+  } else if (match) {
+    return match[1];
+  } else {
+    return tag.replace(/.*-/, '');
+  }
+}
+
+export function findRelease(
+  releases: IGraalPyManifestRelease[],
+  graalpyVersion: string,
+  architecture: string,
+  includePrerelease: boolean
+) {
+  const options = {includePrerelease: includePrerelease};
+  const filterReleases = releases.filter(item => {
+    const isVersionSatisfied = semver.satisfies(
+      graalPyTagToVersion(item.tag_name),
+      graalpyVersion,
+      options
+    );
+    return (
+      isVersionSatisfied && !!findAsset(item, architecture, process.platform)
+    );
+  });
+
+  if (!filterReleases.length) {
+    return null;
+  }
+
+  const sortedReleases = filterReleases.sort((previous, current) =>
+    semver.compare(
+      semver.coerce(graalPyTagToVersion(current.tag_name))!,
+      semver.coerce(graalPyTagToVersion(previous.tag_name))!
+    )
+  );
+
+  const foundRelease = sortedReleases[0];
+  const foundAsset = findAsset(foundRelease, architecture, process.platform);
+
+  return {
+    foundAsset,
+    resolvedGraalPyVersion: graalPyTagToVersion(foundRelease.tag_name)
+  };
+}
+
+export function toGraalPyPlatform(platform: string) {
+  switch (platform) {
+    case 'win32':
+      return 'windows';
+    case 'darwin':
+      return 'macos';
+  }
+  return platform;
+}
+
+export function toGraalPyArchitecture(architecture: string) {
+  switch (architecture) {
+    case 'x64':
+      return 'amd64';
+    case 'arm64':
+      return 'aarch64';
+  }
+  return architecture;
+}
+
+export function findAsset(
+  item: IGraalPyManifestRelease,
+  architecture: string,
+  platform: string
+) {
+  const graalpyArch = toGraalPyArchitecture(architecture);
+  const graalpyPlatform = toGraalPyPlatform(platform);
+  const found = item.assets.filter(
+    file =>
+      file.name.startsWith('graalpy') &&
+      file.name.endsWith(`-${graalpyPlatform}-${graalpyArch}.tar.gz`)
+  );
+  /*
+  In the future there could be more variants of GraalPy for a single release. Pick the shortest name, that one is the most likely to be the primary variant.
+  */
+  found.sort((f1, f2) => f1.name.length - f2.name.length);
+  return found[0];
+}

src/install-pypy.ts

@@ -0,0 +1,295 @@
+import * as os from 'os';
+import * as path from 'path';
+import * as core from '@actions/core';
+import * as tc from '@actions/tool-cache';
+import * as semver from 'semver';
+import * as httpm from '@actions/http-client';
+import * as exec from '@actions/exec';
+import fs from 'fs';
+
+import {
+  IS_LINUX,
+  IS_WINDOWS,
+  WINDOWS_PLATFORMS,
+  IPyPyManifestRelease,
+  createSymlinkInFolder,
+  isNightlyKeyword,
+  writeExactPyPyVersionFile,
+  getBinaryDirectory,
+  getDownloadFileName
+} from './utils';
+
+export async function installPyPy(
+  pypyVersion: string,
+  pythonVersion: string,
+  architecture: string,
+  allowPreReleases: boolean,
+  releases: IPyPyManifestRelease[] | undefined
+) {
+  let downloadDir;
+
+  releases = releases ?? (await getAvailablePyPyVersions());
+
+  if (!releases || releases.length === 0) {
+    throw new Error('No release was found in PyPy version.json');
+  }
+
+  let releaseData = findRelease(
+    releases,
+    pythonVersion,
+    pypyVersion,
+    architecture,
+    false
+  );
+
+  if (allowPreReleases && (!releaseData || !releaseData.foundAsset)) {
+    // check for pre-release
+    core.info(
+      [
+        `Stable PyPy version ${pythonVersion} (${pypyVersion}) with arch ${architecture} not found`,
+        `Trying pre-release versions`
+      ].join(os.EOL)
+    );
+    releaseData = findRelease(
+      releases,
+      pythonVersion,
+      pypyVersion,
+      architecture,
+      true
+    );
+  }
+
+  if (!releaseData || !releaseData.foundAsset) {
+    throw new Error(
+      `PyPy version ${pythonVersion} (${pypyVersion}) with arch ${architecture} not found`
+    );
+  }
+
+  const {foundAsset, resolvedPythonVersion, resolvedPyPyVersion} = releaseData;
+  const downloadUrl = `${foundAsset.download_url}`;
+
+  core.info(`Downloading PyPy from "${downloadUrl}" ...`);
+
+  try {
+    const fileName = getDownloadFileName(downloadUrl);
+    const pypyPath = await tc.downloadTool(downloadUrl, fileName);
+
+    core.info('Extracting downloaded archive...');
+    if (IS_WINDOWS) {
+      downloadDir = await tc.extractZip(pypyPath);
+    } else {
+      downloadDir = await tc.extractTar(pypyPath, undefined, 'x');
+    }
+
+    // root folder in archive can have unpredictable name so just take the first folder
+    // downloadDir is unique folder under TEMP and can't contain any other folders
+    const archiveName = fs.readdirSync(downloadDir)[0];
+
+    const toolDir = path.join(downloadDir, archiveName);
+    let installDir = toolDir;
+    if (!isNightlyKeyword(resolvedPyPyVersion)) {
+      installDir = await tc.cacheDir(
+        toolDir,
+        'PyPy',
+        resolvedPythonVersion,
+        architecture
+      );
+    }
+
+    writeExactPyPyVersionFile(installDir, resolvedPyPyVersion);
+
+    const binaryPath = getBinaryDirectory(installDir);
+    await createPyPySymlink(binaryPath, resolvedPythonVersion);
+    await installPip(binaryPath);
+
+    return {installDir, resolvedPythonVersion, resolvedPyPyVersion};
+  } catch (err) {
+    if (err instanceof Error) {
+      // Rate limit?
+      if (
+        err instanceof tc.HTTPError &&
+        (err.httpStatusCode === 403 || err.httpStatusCode === 429)
+      ) {
+        core.info(
+          `Received HTTP status code ${err.httpStatusCode}.  This usually indicates the rate limit has been exceeded`
+        );
+      } else {
+        core.info(err.message);
+      }
+      if (err.stack !== undefined) {
+        core.debug(err.stack);
+      }
+    }
+    throw err;
+  }
+}
+
+export async function getAvailablePyPyVersions() {
+  const url = 'https://downloads.python.org/pypy/versions.json';
+  const http: httpm.HttpClient = new httpm.HttpClient('tool-cache');
+
+  const response = await http.getJson<IPyPyManifestRelease[]>(url);
+  if (!response.result) {
+    throw new Error(
+      `Unable to retrieve the list of available PyPy versions from '${url}'`
+    );
+  }
+
+  return response.result;
+}
+
+async function createPyPySymlink(
+  pypyBinaryPath: string,
+  pythonVersion: string
+) {
+  const version = semver.coerce(pythonVersion)!;
+  const pythonBinaryPostfix = semver.major(version);
+  const pythonMinor = semver.minor(version);
+  const pypyBinaryPostfix = pythonBinaryPostfix === 2 ? '' : '3';
+  const pypyMajorMinorBinaryPostfix = `${pythonBinaryPostfix}.${pythonMinor}`;
+  const binaryExtension = IS_WINDOWS ? '.exe' : '';
+
+  core.info('Creating symlinks...');
+  createSymlinkInFolder(
+    pypyBinaryPath,
+    `pypy${pypyBinaryPostfix}${binaryExtension}`,
+    `python${pythonBinaryPostfix}${binaryExtension}`,
+    true
+  );
+
+  createSymlinkInFolder(
+    pypyBinaryPath,
+    `pypy${pypyBinaryPostfix}${binaryExtension}`,
+    `python${binaryExtension}`,
+    true
+  );
+
+  createSymlinkInFolder(
+    pypyBinaryPath,
+    `pypy${pypyBinaryPostfix}${binaryExtension}`,
+    `pypy${pypyMajorMinorBinaryPostfix}${binaryExtension}`,
+    true
+  );
+}
+
+async function installPip(pythonLocation: string) {
+  core.info('Installing and updating pip');
+  const pythonBinary = path.join(pythonLocation, 'python');
+  await exec.exec(`${pythonBinary} -m ensurepip`);
+
+  await exec.exec(
+    `${pythonLocation}/python -m pip install --ignore-installed pip`
+  );
+}
+
+export function findRelease(
+  releases: IPyPyManifestRelease[],
+  pythonVersion: string,
+  pypyVersion: string,
+  architecture: string,
+  includePrerelease: boolean
+) {
+  const options = {includePrerelease: includePrerelease};
+  const filterReleases = releases.filter(item => {
+    const isPythonVersionSatisfied = semver.satisfies(
+      semver.coerce(item.python_version)!,
+      pythonVersion
+    );
+    const isPyPyNightly =
+      isNightlyKeyword(pypyVersion) && isNightlyKeyword(item.pypy_version);
+    const isPyPyVersionSatisfied =
+      isPyPyNightly ||
+      semver.satisfies(
+        pypyVersionToSemantic(item.pypy_version),
+        pypyVersion,
+        options
+      );
+    const isArchPresent =
+      item.files &&
+      (IS_WINDOWS
+        ? isArchPresentForWindows(item, architecture)
+        : isArchPresentForMacOrLinux(item, architecture, process.platform));
+    return isPythonVersionSatisfied && isPyPyVersionSatisfied && isArchPresent;
+  });
+
+  if (filterReleases.length === 0) {
+    return null;
+  }
+
+  const sortedReleases = filterReleases.sort((previous, current) => {
+    return (
+      semver.compare(
+        semver.coerce(pypyVersionToSemantic(current.pypy_version))!,
+        semver.coerce(pypyVersionToSemantic(previous.pypy_version))!
+      ) ||
+      semver.compare(
+        semver.coerce(current.python_version)!,
+        semver.coerce(previous.python_version)!
+      )
+    );
+  });
+
+  const foundRelease = sortedReleases[0];
+  const foundAsset = IS_WINDOWS
+    ? findAssetForWindows(foundRelease, architecture)
+    : findAssetForMacOrLinux(foundRelease, architecture, process.platform);
+
+  return {
+    foundAsset,
+    resolvedPythonVersion: foundRelease.python_version,
+    resolvedPyPyVersion: foundRelease.pypy_version.trim()
+  };
+}
+
+export function pypyVersionToSemantic(versionSpec: string) {
+  const prereleaseVersion = /(\d+\.\d+\.\d+)((?:a|b|rc))(\d*)/g;
+  return versionSpec.replace(prereleaseVersion, '$1-$2.$3');
+}
+
+export function isArchPresentForWindows(item: any, architecture: string) {
+  architecture = pypyArchitecture(architecture);
+  return item.files.some(
+    (file: any) =>
+      WINDOWS_PLATFORMS.includes(file.platform) && file.arch === architecture
+  );
+}
+
+export function isArchPresentForMacOrLinux(
+  item: any,
+  architecture: string,
+  platform: string
+) {
+  architecture = pypyArchitecture(architecture);
+  return item.files.some(
+    (file: any) => file.arch === architecture && file.platform === platform
+  );
+}
+
+export function findAssetForWindows(releases: any, architecture: string) {
+  architecture = pypyArchitecture(architecture);
+  return releases.files.find(
+    (item: any) =>
+      WINDOWS_PLATFORMS.includes(item.platform) && item.arch === architecture
+  );
+}
+
+export function findAssetForMacOrLinux(
+  releases: any,
+  architecture: string,
+  platform: string
+) {
+  architecture = pypyArchitecture(architecture);
+  return releases.files.find(
+    (item: any) => item.arch === architecture && item.platform === platform
+  );
+}
+
+function pypyArchitecture(architecture: string): string {
+  if (IS_WINDOWS && architecture === 'x32') {
+    // convert x32 to x86 because os.arch() returns x32 for 32-bit systems but PyPy releases json has x86 arch value.
+    architecture = 'x86';
+  } else if (IS_LINUX && architecture === 'arm64') {
+    architecture = 'aarch64';
+  }
+  return architecture;
+}

src/install-python.ts

@@ -0,0 +1,164 @@
+import * as path from 'path';
+import * as core from '@actions/core';
+import * as tc from '@actions/tool-cache';
+import * as exec from '@actions/exec';
+import * as httpm from '@actions/http-client';
+import {ExecOptions} from '@actions/exec/lib/interfaces';
+import {IS_WINDOWS, IS_LINUX, getDownloadFileName} from './utils';
+import {IToolRelease} from '@actions/tool-cache';
+
+const TOKEN = core.getInput('token');
+const AUTH = !TOKEN ? undefined : `token ${TOKEN}`;
+const MANIFEST_REPO_OWNER = 'actions';
+const MANIFEST_REPO_NAME = 'python-versions';
+const MANIFEST_REPO_BRANCH = 'main';
+export const MANIFEST_URL = `https://raw.githubusercontent.com/${MANIFEST_REPO_OWNER}/${MANIFEST_REPO_NAME}/${MANIFEST_REPO_BRANCH}/versions-manifest.json`;
+
+export async function findReleaseFromManifest(
+  semanticVersionSpec: string,
+  architecture: string,
+  manifest: tc.IToolRelease[] | null
+): Promise<tc.IToolRelease | undefined> {
+  if (!manifest) {
+    manifest = await getManifest();
+  }
+
+  const foundRelease = await tc.findFromManifest(
+    semanticVersionSpec,
+    false,
+    manifest,
+    architecture
+  );
+
+  return foundRelease;
+}
+function isIToolRelease(obj: any): obj is IToolRelease {
+  return (
+    typeof obj === 'object' &&
+    obj !== null &&
+    typeof obj.version === 'string' &&
+    typeof obj.stable === 'boolean' &&
+    Array.isArray(obj.files) &&
+    obj.files.every(
+      (file: any) =>
+        typeof file.filename === 'string' &&
+        typeof file.platform === 'string' &&
+        typeof file.arch === 'string' &&
+        typeof file.download_url === 'string'
+    )
+  );
+}
+export async function getManifest(): Promise<tc.IToolRelease[]> {
+  try {
+    const repoManifest = await getManifestFromRepo();
+    if (
+      Array.isArray(repoManifest) &&
+      repoManifest.length &&
+      repoManifest.every(isIToolRelease)
+    ) {
+      return repoManifest;
+    }
+    throw new Error(
+      'The repository manifest is invalid or does not include any valid tool release (IToolRelease) entries.'
+    );
+  } catch (err) {
+    core.debug('Fetching the manifest via the API failed.');
+    if (err instanceof Error) {
+      core.debug(err.message);
+    } else {
+      core.error('An unexpected error occurred while fetching the manifest.');
+    }
+  }
+  return await getManifestFromURL();
+}
+
+export function getManifestFromRepo(): Promise<tc.IToolRelease[]> {
+  core.debug(
+    `Getting manifest from ${MANIFEST_REPO_OWNER}/${MANIFEST_REPO_NAME}@${MANIFEST_REPO_BRANCH}`
+  );
+  return tc.getManifestFromRepo(
+    MANIFEST_REPO_OWNER,
+    MANIFEST_REPO_NAME,
+    AUTH,
+    MANIFEST_REPO_BRANCH
+  );
+}
+
+export async function getManifestFromURL(): Promise<tc.IToolRelease[]> {
+  core.debug('Falling back to fetching the manifest using raw URL.');
+
+  const http: httpm.HttpClient = new httpm.HttpClient('tool-cache');
+  const response = await http.getJson<tc.IToolRelease[]>(MANIFEST_URL);
+  if (!response.result) {
+    throw new Error(`Unable to get manifest from ${MANIFEST_URL}`);
+  }
+  return response.result;
+}
+
+async function installPython(workingDirectory: string) {
+  const options: ExecOptions = {
+    cwd: workingDirectory,
+    env: {
+      ...process.env,
+      ...(IS_LINUX && {LD_LIBRARY_PATH: path.join(workingDirectory, 'lib')})
+    },
+    silent: true,
+    listeners: {
+      stdout: (data: Buffer) => {
+        core.info(data.toString().trim());
+      },
+      stderr: (data: Buffer) => {
+        core.error(data.toString().trim());
+      }
+    }
+  };
+
+  if (IS_WINDOWS) {
+    await exec.exec('powershell', ['./setup.ps1'], options);
+  } else {
+    await exec.exec('bash', ['./setup.sh'], options);
+  }
+}
+
+export async function installCpythonFromRelease(release: tc.IToolRelease) {
+  if (!release.files || release.files.length === 0) {
+    throw new Error('No files found in the release to download.');
+  }
+  const downloadUrl = release.files[0].download_url;
+
+  core.info(`Download from "${downloadUrl}"`);
+  let pythonPath = '';
+  try {
+    const fileName = getDownloadFileName(downloadUrl);
+    pythonPath = await tc.downloadTool(downloadUrl, fileName, AUTH);
+    core.info('Extract downloaded archive');
+    let pythonExtractedFolder;
+    if (IS_WINDOWS) {
+      pythonExtractedFolder = await tc.extractZip(pythonPath);
+    } else {
+      pythonExtractedFolder = await tc.extractTar(pythonPath);
+    }
+
+    core.info('Execute installation script');
+    await installPython(pythonExtractedFolder);
+  } catch (err) {
+    if (err instanceof tc.HTTPError) {
+      // Rate limit?
+      if (err.httpStatusCode === 403) {
+        core.error(
+          `Received HTTP status code 403. This indicates a permission issue or restricted access.`
+        );
+      } else if (err.httpStatusCode === 429) {
+        core.info(
+          `Received HTTP status code 429.  This usually indicates the rate limit has been exceeded`
+        );
+      } else {
+        core.info(err.message);
+      }
+      if (err.stack) {
+        core.debug(err.stack);
+      }
+    }
+    throw err;
+  }
+}

src/setup-python.ts

@@ -0,0 +1,160 @@
+import * as core from '@actions/core';
+import * as finder from './find-python';
+import * as finderPyPy from './find-pypy';
+import * as finderGraalPy from './find-graalpy';
+import * as path from 'path';
+import * as os from 'os';
+import fs from 'fs';
+import {getCacheDistributor} from './cache-distributions/cache-factory';
+import {
+  isCacheFeatureAvailable,
+  logWarning,
+  IS_MAC,
+  getVersionInputFromFile,
+  getVersionInputFromPlainFile
+} from './utils';
+
+function isPyPyVersion(versionSpec: string) {
+  return versionSpec.startsWith('pypy');
+}
+
+function isGraalPyVersion(versionSpec: string) {
+  return versionSpec.startsWith('graalpy');
+}
+
+async function cacheDependencies(cache: string, pythonVersion: string) {
+  const cacheDependencyPath =
+    core.getInput('cache-dependency-path') || undefined;
+  const cacheDistributor = getCacheDistributor(
+    cache,
+    pythonVersion,
+    cacheDependencyPath
+  );
+  await cacheDistributor.restoreCache();
+}
+
+function resolveVersionInputFromDefaultFile(): string[] {
+  const couples: [string, (versionFile: string) => string[]][] = [
+    ['.python-version', getVersionInputFromPlainFile]
+  ];
+  for (const [versionFile, _fn] of couples) {
+    logWarning(
+      `Neither 'python-version' nor 'python-version-file' inputs were supplied. Attempting to find '${versionFile}' file.`
+    );
+    if (fs.existsSync(versionFile)) {
+      return _fn(versionFile);
+    } else {
+      logWarning(`${versionFile} doesn't exist.`);
+    }
+  }
+  return [];
+}
+
+function resolveVersionInput() {
+  let versions = core.getMultilineInput('python-version');
+  const versionFile = core.getInput('python-version-file');
+
+  if (versions.length) {
+    if (versionFile) {
+      core.warning(
+        'Both python-version and python-version-file inputs are specified, only python-version will be used.'
+      );
+    }
+  } else {
+    if (versionFile) {
+      if (!fs.existsSync(versionFile)) {
+        throw new Error(
+          `The specified python version file at: ${versionFile} doesn't exist.`
+        );
+      }
+      versions = getVersionInputFromFile(versionFile);
+    } else {
+      versions = resolveVersionInputFromDefaultFile();
+    }
+  }
+
+  return versions;
+}
+
+async function run() {
+  if (IS_MAC) {
+    process.env['AGENT_TOOLSDIRECTORY'] = '/Users/runner/hostedtoolcache';
+  }
+
+  if (process.env.AGENT_TOOLSDIRECTORY?.trim()) {
+    process.env['RUNNER_TOOL_CACHE'] = process.env['AGENT_TOOLSDIRECTORY'];
+  }
+
+  core.debug(
+    `Python is expected to be installed into ${process.env['RUNNER_TOOL_CACHE']}`
+  );
+  try {
+    const versions = resolveVersionInput();
+    const checkLatest = core.getBooleanInput('check-latest');
+    const allowPreReleases = core.getBooleanInput('allow-prereleases');
+    const freethreaded = core.getBooleanInput('freethreaded');
+
+    if (versions.length) {
+      let pythonVersion = '';
+      const arch: string = core.getInput('architecture') || os.arch();
+      const updateEnvironment = core.getBooleanInput('update-environment');
+      core.startGroup('Installed versions');
+      for (const version of versions) {
+        if (isPyPyVersion(version)) {
+          const installed = await finderPyPy.findPyPyVersion(
+            version,
+            arch,
+            updateEnvironment,
+            checkLatest,
+            allowPreReleases
+          );
+          pythonVersion = `${installed.resolvedPyPyVersion}-${installed.resolvedPythonVersion}`;
+          core.info(
+            `Successfully set up PyPy ${installed.resolvedPyPyVersion} with Python (${installed.resolvedPythonVersion})`
+          );
+        } else if (isGraalPyVersion(version)) {
+          const installed = await finderGraalPy.findGraalPyVersion(
+            version,
+            arch,
+            updateEnvironment,
+            checkLatest,
+            allowPreReleases
+          );
+          pythonVersion = `${installed}`;
+          core.info(`Successfully set up GraalPy ${installed}`);
+        } else {
+          if (version.startsWith('2')) {
+            core.warning(
+              'The support for python 2.7 was removed on June 19, 2023. Related issue: https://github.com/actions/setup-python/issues/672'
+            );
+          }
+          const installed = await finder.useCpythonVersion(
+            version,
+            arch,
+            updateEnvironment,
+            checkLatest,
+            allowPreReleases,
+            freethreaded
+          );
+          pythonVersion = installed.version;
+          core.info(`Successfully set up ${installed.impl} (${pythonVersion})`);
+        }
+      }
+      core.endGroup();
+      const cache = core.getInput('cache');
+      if (cache && isCacheFeatureAvailable()) {
+        await cacheDependencies(cache, pythonVersion);
+      }
+    } else {
+      core.warning(
+        'The `python-version` input is not set.  The version of Python currently in `PATH` will be used.'
+      );
+    }
+    const matchersPath = path.join(__dirname, '../..', '.github');
+    core.info(`##[add-matcher]${path.join(matchersPath, 'python.json')}`);
+  } catch (err) {
+    core.setFailed((err as Error).message);
+  }
+}
+
+run();

src/utils.ts

@@ -0,0 +1,369 @@
+/* eslint no-unsafe-finally: "off" */
+import * as cache from '@actions/cache';
+import * as core from '@actions/core';
+import fs from 'fs';
+import * as path from 'path';
+import * as semver from 'semver';
+import * as toml from '@iarna/toml';
+import * as exec from '@actions/exec';
+import * as ifm from '@actions/http-client/lib/interfaces';
+
+import * as http from 'http';
+
+export const IS_WINDOWS = process.platform === 'win32';
+export const IS_LINUX = process.platform === 'linux';
+export const IS_MAC = process.platform === 'darwin';
+export const WINDOWS_ARCHS = ['x86', 'x64'];
+export const WINDOWS_PLATFORMS = ['win32', 'win64'];
+const PYPY_VERSION_FILE = 'PYPY_VERSION';
+
+export interface IPyPyManifestAsset {
+  filename: string;
+  arch: string;
+  platform: string;
+  download_url: string;
+}
+
+export interface IPyPyManifestRelease {
+  pypy_version: string;
+  python_version: string;
+  stable: boolean;
+  latest_pypy: boolean;
+  files: IPyPyManifestAsset[];
+}
+
+export interface IGraalPyManifestAsset {
+  name: string;
+  browser_download_url: string;
+}
+
+export interface IGraalPyManifestRelease {
+  tag_name: string;
+  assets: IGraalPyManifestAsset[];
+}
+
+/** create Symlinks for downloaded PyPy
+ *  It should be executed only for downloaded versions in runtime, because
+ *  toolcache versions have this setup.
+ */
+export function createSymlinkInFolder(
+  folderPath: string,
+  sourceName: string,
+  targetName: string,
+  setExecutable = false
+) {
+  const sourcePath = path.join(folderPath, sourceName);
+  const targetPath = path.join(folderPath, targetName);
+  if (fs.existsSync(targetPath)) {
+    return;
+  }
+
+  fs.symlinkSync(sourcePath, targetPath);
+  if (!IS_WINDOWS && setExecutable) {
+    fs.chmodSync(targetPath, '755');
+  }
+}
+
+export function validateVersion(version: string) {
+  return isNightlyKeyword(version) || Boolean(semver.validRange(version));
+}
+
+export function isNightlyKeyword(pypyVersion: string) {
+  return pypyVersion === 'nightly';
+}
+
+export function getPyPyVersionFromPath(installDir: string) {
+  return path.basename(path.dirname(installDir));
+}
+
+/**
+ * In tool-cache, we put PyPy to '<toolcache_root>/PyPy/<python_version>/x64'
+ * There is no easy way to determine what PyPy version is located in specific folder
+ * 'pypy --version' is not reliable enough since it is not set properly for preview versions
+ * "7.3.3rc1" is marked as '7.3.3' in 'pypy --version'
+ * so we put PYPY_VERSION file to PyPy directory when install it to VM and read it when we need to know version
+ * PYPY_VERSION contains exact version from 'versions.json'
+ */
+export function readExactPyPyVersionFile(installDir: string) {
+  let pypyVersion = '';
+  const fileVersion = path.join(installDir, PYPY_VERSION_FILE);
+  if (fs.existsSync(fileVersion)) {
+    pypyVersion = fs.readFileSync(fileVersion).toString().trim();
+  }
+
+  return pypyVersion;
+}
+
+export function writeExactPyPyVersionFile(
+  installDir: string,
+  resolvedPyPyVersion: string
+) {
+  const pypyFilePath = path.join(installDir, PYPY_VERSION_FILE);
+  fs.writeFileSync(pypyFilePath, resolvedPyPyVersion);
+}
+
+/**
+ * Python version should be specified explicitly like "x.y" (3.10, 3.11, etc)
+ * "3.x" or "3" are not supported
+ * because it could cause ambiguity when both PyPy version and Python version are not precise
+ */
+export function validatePythonVersionFormatForPyPy(version: string) {
+  const re = /^\d+\.\d+$/;
+  return re.test(version);
+}
+
+export function isGhes(): boolean {
+  const ghUrl = new URL(
+    process.env['GITHUB_SERVER_URL'] || 'https://github.com'
+  );
+
+  const hostname = ghUrl.hostname.trimEnd().toUpperCase();
+  const isGitHubHost = hostname === 'GITHUB.COM';
+  const isGitHubEnterpriseCloudHost = hostname.endsWith('.GHE.COM');
+  const isLocalHost = hostname.endsWith('.LOCALHOST');
+
+  return !isGitHubHost && !isGitHubEnterpriseCloudHost && !isLocalHost;
+}
+
+export function isCacheFeatureAvailable(): boolean {
+  if (cache.isFeatureAvailable()) {
+    return true;
+  }
+
+  if (isGhes()) {
+    core.warning(
+      'Caching is only supported on GHES version >= 3.5. If you are on a version >= 3.5, please check with your GHES admin if the Actions cache service is enabled or not.'
+    );
+    return false;
+  }
+
+  core.warning(
+    'The runner was not able to contact the cache service. Caching will be skipped'
+  );
+  return false;
+}
+
+export function logWarning(message: string): void {
+  const warningPrefix = '[warning]';
+  core.info(`${warningPrefix}${message}`);
+}
+
+async function getWindowsInfo() {
+  const {stdout} = await exec.getExecOutput(
+    'powershell -command "(Get-CimInstance -ClassName Win32_OperatingSystem).Caption"',
+    undefined,
+    {
+      silent: true
+    }
+  );
+
+  const windowsVersion = stdout.trim().split(' ')[3];
+
+  return {osName: 'Windows', osVersion: windowsVersion};
+}
+
+async function getMacOSInfo() {
+  const {stdout} = await exec.getExecOutput('sw_vers', ['-productVersion'], {
+    silent: true
+  });
+
+  const macOSVersion = stdout.trim();
+
+  return {osName: 'macOS', osVersion: macOSVersion};
+}
+
+export async function getLinuxInfo() {
+  const {stdout} = await exec.getExecOutput('lsb_release', ['-i', '-r', '-s'], {
+    silent: true
+  });
+
+  const [osName, osVersion] = stdout.trim().split('\n');
+
+  core.debug(`OS Name: ${osName}, Version: ${osVersion}`);
+
+  return {osName: osName, osVersion: osVersion};
+}
+
+export async function getOSInfo() {
+  let osInfo;
+  try {
+    if (IS_WINDOWS) {
+      osInfo = await getWindowsInfo();
+    } else if (IS_LINUX) {
+      osInfo = await getLinuxInfo();
+    } else if (IS_MAC) {
+      osInfo = await getMacOSInfo();
+    }
+  } catch (err) {
+    const error = err as Error;
+    core.debug(error.message);
+  } finally {
+    return osInfo;
+  }
+}
+
+/**
+ * Extract a value from an object by following the keys path provided.
+ * If the value is present, it is returned. Otherwise undefined is returned.
+ */
+function extractValue(obj: any, keys: string[]): string | undefined {
+  if (keys.length > 0) {
+    const value = obj[keys[0]];
+    if (keys.length > 1 && value !== undefined) {
+      return extractValue(value, keys.slice(1));
+    } else {
+      return value;
+    }
+  } else {
+    return;
+  }
+}
+
+/**
+ * Python version extracted from the TOML file.
+ * If the `project` key is present at the root level, the version is assumed to
+ * be specified according to PEP 621 in `project.requires-python`.
+ * Otherwise, if the `tool` key is present at the root level, the version is
+ * assumed to be specified using poetry under `tool.poetry.dependencies.python`.
+ * If none is present, returns an empty list.
+ */
+export function getVersionInputFromTomlFile(versionFile: string): string[] {
+  core.debug(`Trying to resolve version form ${versionFile}`);
+
+  let pyprojectFile = fs.readFileSync(versionFile, 'utf8');
+  // Normalize the line endings in the pyprojectFile
+  pyprojectFile = pyprojectFile.replace(/\r\n/g, '\n');
+
+  const pyprojectConfig = toml.parse(pyprojectFile);
+  let keys = [];
+
+  if ('project' in pyprojectConfig) {
+    // standard project metadata (PEP 621)
+    keys = ['project', 'requires-python'];
+  } else {
+    // python poetry
+    keys = ['tool', 'poetry', 'dependencies', 'python'];
+  }
+  const versions = [];
+  const version = extractValue(pyprojectConfig, keys);
+  if (version !== undefined) {
+    versions.push(version);
+  }
+
+  core.info(`Extracted ${versions} from ${versionFile}`);
+  const rawVersions = Array.from(versions, version =>
+    version.split(',').join(' ')
+  );
+  const validatedVersions = rawVersions
+    .map(item => semver.validRange(item, true))
+    .filter((versionRange, index) => {
+      if (!versionRange) {
+        core.debug(
+          `The version ${rawVersions[index]} is not valid SemVer range`
+        );
+      }
+
+      return !!versionRange;
+    }) as string[];
+  return validatedVersions;
+}
+
+/**
+ * Python version extracted from a plain text file.
+ */
+export function getVersionInputFromPlainFile(versionFile: string): string[] {
+  core.debug(`Trying to resolve version form ${versionFile}`);
+  const version = fs.readFileSync(versionFile, 'utf8').trim();
+  core.info(`Resolved ${versionFile} as ${version}`);
+  return [version];
+}
+
+/**
+ * Python version extracted from a .tool-versions file.
+ */
+export function getVersionInputFromToolVersions(versionFile: string): string[] {
+  if (!fs.existsSync(versionFile)) {
+    core.warning(`File ${versionFile} does not exist.`);
+    return [];
+  }
+
+  try {
+    const fileContents = fs.readFileSync(versionFile, 'utf8');
+    const lines = fileContents.split('\n');
+
+    for (const line of lines) {
+      // Skip commented lines
+      if (line.trim().startsWith('#')) {
+        continue;
+      }
+      const match = line.match(/^\s*python\s*v?\s*(?<version>[^\s]+)\s*$/);
+      if (match) {
+        return [match.groups?.version.trim() || ''];
+      }
+    }
+
+    core.warning(`No Python version found in ${versionFile}`);
+
+    return [];
+  } catch (error) {
+    core.error(`Error reading ${versionFile}: ${(error as Error).message}`);
+    return [];
+  }
+}
+/**
+ * Python version extracted from a plain, .tool-versions or TOML file.
+ */
+export function getVersionInputFromFile(versionFile: string): string[] {
+  if (versionFile.endsWith('.toml')) {
+    return getVersionInputFromTomlFile(versionFile);
+  } else if (versionFile.match('.tool-versions')) {
+    return getVersionInputFromToolVersions(versionFile);
+  } else {
+    return getVersionInputFromPlainFile(versionFile);
+  }
+}
+
+/**
+ * Get the directory containing interpreter binary from installation directory of PyPy or GraalPy
+ *  - On Linux and macOS, the Python interpreter is in 'bin'.
+ *  - On Windows, it is in the installation root.
+ */
+export function getBinaryDirectory(installDir: string) {
+  return IS_WINDOWS ? installDir : path.join(installDir, 'bin');
+}
+
+/**
+ * Extract next page URL from a HTTP response "link" header. Such headers are used in GitHub APIs.
+ */
+export function getNextPageUrl<T>(response: ifm.TypedResponse<T>) {
+  const responseHeaders = <http.OutgoingHttpHeaders>response.headers;
+  const linkHeader = responseHeaders.link;
+  if (typeof linkHeader === 'string') {
+    for (const link of linkHeader.split(/\s*,\s*/)) {
+      const match = link.match(/<([^>]+)>(.*)/);
+      if (match) {
+        const url = match[1];
+        for (const param of match[2].split(/\s*;\s*/)) {
+          if (param.match(/rel="?next"?/)) {
+            return url;
+          }
+        }
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Add temporary fix for Windows
+ * On Windows, it is necessary to retain the .zip extension for proper extraction.
+ * because the tc.extractZip() failure due to tc.downloadTool() not adding .zip extension.
+ * Related issue: https://github.com/actions/toolkit/issues/1179
+ * Related issue: https://github.com/actions/setup-python/issues/819
+ */
+export function getDownloadFileName(downloadUrl: string): string | undefined {
+  const tempDir = process.env.RUNNER_TEMP || '.';
+  return IS_WINDOWS
+    ? path.join(tempDir, path.basename(downloadUrl))
+    : undefined;
+}