Files
setup-uv/src/version/resolve.ts
T
yamamoto7andClaude Opus 5.5 898180d41d fix: resolve partial PEP 440 specifiers with PEP 440 semantics (#1128)
## 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>
2026-11-12 15:12:48 +01:00

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;
}