mirror of
https://github.com/astral-sh/setup-uv.git
synced 2026-11-20 23:56:00 +00:00
## Summary `<=`, `==` and `>` with a partial version are valid PEP 440 specifiers, but the resolver tries them as semver ranges first, and semver reads them differently: | specifier | semver (before) | PEP 440 (what uv enforces) | |---|---|---| | `<=0.5` | `<0.6.0`, installs 0.5.31 | `<=0.5.0`, installs 0.5.0 | | `==0.5` | `==` is stripped and `0.5` is read as `0.5.x`, installs 0.5.31 | `==0.5.0`, installs 0.5.0 | | `>0.5` with `resolution-strategy: lowest` | `>=0.6.0`, installs 0.6.0 | `>0.5.0`, installs 0.5.1 | So `required-version = "<=0.5"` or `"==0.5"` in `uv.toml` / `pyproject.toml` installs a uv that does not satisfy the project's own `required-version`, and uv refuses to run there (`Required uv version ... does not match the running version ...`). This is the same problem #1111 fixed for `~=`. Instead of adding more operators to that check, specifiers that `@renovatebot/pep440` accepts as a valid range now skip the semver evaluation, and `==` is only stripped from a full version, so `==0.5` stays a PEP 440 pin. Notes: - Semver-only syntax is not valid PEP 440 and still goes through semver: `0.4.x`, `^0.5`, `~0.5`, `>=0.4.0 <0.5.0` and a bare `0.5`. - Inputs that are valid in both, like `>=0.4.0` from the docs, now go through PEP 440. They mean the same in both, and the PEP 440 path uses the same first-match lookup over the manifest. - Full pins like `==0.9.26` still resolve as explicit versions, and compound specifiers like `>=0.4,<=0.5` already went through PEP 440. ## Test plan - Added cases for `<=0.9` and `==0.9` with the default strategy and `>0.9` with `lowest` in `download-version.test.ts`. All three fail without the change. - `npm ci --ignore-scripts`, then `npm run build`, `npm run check` (no fixes), `npm run package` and `npm run test:unit` on macOS with Node 24.13.0: 179 tests across 16 suites pass. The rebuilt `dist/setup/index.cjs` only differs in the changed functions. Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
253 lines
7.2 KiB
TypeScript
253 lines
7.2 KiB
TypeScript
import * as core from "@actions/core";
|
|
import * as tc from "@actions/tool-cache";
|
|
import * as pep440 from "@renovatebot/pep440";
|
|
import * as semver from "semver";
|
|
import { getLatestKnownVersion } from "../download/checksum/known-version";
|
|
import {
|
|
getAllVersions,
|
|
getFirstMatchingVersion,
|
|
getLatestVersion,
|
|
} from "../download/manifest";
|
|
import { VERSIONS_MANIFEST_URL } from "../utils/constants";
|
|
import type { ResolutionStrategy } from "../utils/inputs";
|
|
import * as log from "../utils/logging";
|
|
import {
|
|
type ParsedVersionSpecifier,
|
|
parseVersionSpecifier,
|
|
} from "./specifier";
|
|
import type { ResolveUvVersionOptions } from "./types";
|
|
import { resolveVersionRequest } from "./version-request-resolver";
|
|
|
|
interface ConcreteVersionResolutionContext {
|
|
manifestUrl?: string;
|
|
parsedSpecifier: ParsedVersionSpecifier;
|
|
resolutionStrategy: ResolutionStrategy;
|
|
}
|
|
|
|
interface ConcreteVersionResolver {
|
|
resolve(
|
|
context: ConcreteVersionResolutionContext,
|
|
): Promise<string | undefined>;
|
|
}
|
|
|
|
class ExactVersionResolver implements ConcreteVersionResolver {
|
|
async resolve(
|
|
context: ConcreteVersionResolutionContext,
|
|
): Promise<string | undefined> {
|
|
if (context.parsedSpecifier.kind !== "exact") {
|
|
return undefined;
|
|
}
|
|
|
|
core.debug(
|
|
`Version ${context.parsedSpecifier.normalized} is an explicit version.`,
|
|
);
|
|
return context.parsedSpecifier.normalized;
|
|
}
|
|
}
|
|
|
|
class LatestVersionResolver implements ConcreteVersionResolver {
|
|
async resolve(
|
|
context: ConcreteVersionResolutionContext,
|
|
): Promise<string | undefined> {
|
|
const shouldUseLatestVersion =
|
|
context.parsedSpecifier.kind === "latest" ||
|
|
(context.parsedSpecifier.kind === "range" &&
|
|
context.parsedSpecifier.isSimpleMinimumVersionSpecifier &&
|
|
context.resolutionStrategy === "highest");
|
|
|
|
if (!shouldUseLatestVersion) {
|
|
return undefined;
|
|
}
|
|
|
|
if (
|
|
context.parsedSpecifier.kind === "range" &&
|
|
context.parsedSpecifier.isSimpleMinimumVersionSpecifier
|
|
) {
|
|
log.info("Found minimum version specifier, using latest version");
|
|
}
|
|
|
|
const latestVersion = await getLatestVersion(context.manifestUrl);
|
|
|
|
if (
|
|
context.parsedSpecifier.kind === "range" &&
|
|
context.parsedSpecifier.isSimpleMinimumVersionSpecifier &&
|
|
!pep440.satisfies(latestVersion, context.parsedSpecifier.raw)
|
|
) {
|
|
throw new Error(`No version found for ${context.parsedSpecifier.raw}`);
|
|
}
|
|
|
|
return latestVersion;
|
|
}
|
|
}
|
|
|
|
class RangeVersionResolver implements ConcreteVersionResolver {
|
|
async resolve(
|
|
context: ConcreteVersionResolutionContext,
|
|
): Promise<string | undefined> {
|
|
if (context.parsedSpecifier.kind !== "range") {
|
|
return undefined;
|
|
}
|
|
|
|
let resolvedVersion: string | undefined;
|
|
if (
|
|
context.resolutionStrategy === "highest" &&
|
|
(context.manifestUrl === undefined ||
|
|
context.manifestUrl === VERSIONS_MANIFEST_URL)
|
|
) {
|
|
resolvedVersion = await findHighestSatisfyingVersion(
|
|
context.parsedSpecifier.normalized,
|
|
);
|
|
} else {
|
|
const availableVersions = await getAllVersions(context.manifestUrl);
|
|
core.debug(`Available versions: ${availableVersions}`);
|
|
resolvedVersion =
|
|
context.resolutionStrategy === "lowest"
|
|
? minSatisfying(availableVersions, context.parsedSpecifier.normalized)
|
|
: maxSatisfying(
|
|
availableVersions,
|
|
context.parsedSpecifier.normalized,
|
|
);
|
|
}
|
|
|
|
if (resolvedVersion === undefined) {
|
|
throw new Error(`No version found for ${context.parsedSpecifier.raw}`);
|
|
}
|
|
|
|
return resolvedVersion;
|
|
}
|
|
}
|
|
|
|
const CONCRETE_VERSION_RESOLVERS: ConcreteVersionResolver[] = [
|
|
new ExactVersionResolver(),
|
|
new LatestVersionResolver(),
|
|
new RangeVersionResolver(),
|
|
];
|
|
|
|
export async function resolveUvVersion(
|
|
options: ResolveUvVersionOptions,
|
|
): Promise<string> {
|
|
const request = resolveVersionRequest(options);
|
|
const resolutionStrategy = options.resolutionStrategy ?? "highest";
|
|
const version = await resolveVersion(
|
|
request.specifier,
|
|
options.manifestFile,
|
|
resolutionStrategy,
|
|
);
|
|
|
|
return version;
|
|
}
|
|
|
|
export async function resolveVersion(
|
|
versionInput: string,
|
|
manifestUrl: string | undefined,
|
|
resolutionStrategy: ResolutionStrategy = "highest",
|
|
): Promise<string> {
|
|
core.debug(`Resolving version: ${versionInput}`);
|
|
|
|
if (versionInput.trim() === "latest-known") {
|
|
return getLatestKnownVersion();
|
|
}
|
|
|
|
const context: ConcreteVersionResolutionContext = {
|
|
manifestUrl,
|
|
parsedSpecifier: parseVersionSpecifier(versionInput),
|
|
resolutionStrategy,
|
|
};
|
|
|
|
for (const resolver of CONCRETE_VERSION_RESOLVERS) {
|
|
const version = await resolver.resolve(context);
|
|
if (version !== undefined) {
|
|
return version;
|
|
}
|
|
}
|
|
|
|
throw new Error(`No version found for ${versionInput}`);
|
|
}
|
|
|
|
async function findHighestSatisfyingVersion(
|
|
versionSpecifier: string,
|
|
): Promise<string | undefined> {
|
|
// This fast path assumes uv releases are semver-monotonic: newer manifest
|
|
// entries always have higher versions, with no lower-version backports.
|
|
const semverRange = isPep440Specifier(versionSpecifier)
|
|
? null
|
|
: semver.validRange(versionSpecifier);
|
|
if (semverRange !== null) {
|
|
const semverMatch = await getFirstMatchingVersion((version) =>
|
|
semver.satisfies(version, semverRange),
|
|
);
|
|
if (semverMatch !== undefined) {
|
|
core.debug(
|
|
`Found a version that satisfies the semver range: ${semverMatch}`,
|
|
);
|
|
return semverMatch;
|
|
}
|
|
}
|
|
|
|
const pep440Match = await getFirstMatchingVersion((version) =>
|
|
pep440.satisfies(version, versionSpecifier),
|
|
);
|
|
if (pep440Match !== undefined) {
|
|
core.debug(
|
|
`Found a version that satisfies the pep440 specifier: ${pep440Match}`,
|
|
);
|
|
}
|
|
return pep440Match;
|
|
}
|
|
|
|
/**
|
|
* Specifiers that are valid PEP 440 must be evaluated as PEP 440. semver
|
|
* accepts several of them with different semantics, e.g. `~=0.5` as `<0.6.0`
|
|
* instead of `<1.0`, `<=0.5` as `<0.6.0` instead of `<=0.5.0` and `>0.5` as
|
|
* `>=0.6.0` instead of `>0.5.0`.
|
|
*/
|
|
function isPep440Specifier(versionSpecifier: string): boolean {
|
|
return pep440.validRange(versionSpecifier);
|
|
}
|
|
|
|
function maxSatisfying(
|
|
versions: string[],
|
|
version: string,
|
|
): string | undefined {
|
|
const maxSemver = isPep440Specifier(version)
|
|
? ""
|
|
: tc.evaluateVersions(versions, version);
|
|
if (maxSemver !== "") {
|
|
core.debug(`Found a version that satisfies the semver range: ${maxSemver}`);
|
|
return maxSemver;
|
|
}
|
|
|
|
const maxPep440 = pep440.maxSatisfying(versions, version);
|
|
if (maxPep440 !== null) {
|
|
core.debug(
|
|
`Found a version that satisfies the pep440 specifier: ${maxPep440}`,
|
|
);
|
|
return maxPep440;
|
|
}
|
|
|
|
return undefined;
|
|
}
|
|
|
|
function minSatisfying(
|
|
versions: string[],
|
|
version: string,
|
|
): string | undefined {
|
|
const minSemver = isPep440Specifier(version)
|
|
? null
|
|
: semver.minSatisfying(versions, version);
|
|
if (minSemver !== null) {
|
|
core.debug(`Found a version that satisfies the semver range: ${minSemver}`);
|
|
return minSemver;
|
|
}
|
|
|
|
const minPep440 = pep440.minSatisfying(versions, version);
|
|
if (minPep440 !== null) {
|
|
core.debug(
|
|
`Found a version that satisfies the pep440 specifier: ${minPep440}`,
|
|
);
|
|
return minPep440;
|
|
}
|
|
|
|
return undefined;
|
|
}
|