Detect required-version from config file (#233)

1. If defined use version input
2. If defined use uv-file input
3. If defined use pyproject-file input
4. Search for required-version in uv.toml in repo root
5. Search for required-version in pyproject.toml in repo root
6. Use latest

Closes: #215

src/setup-uv.ts

@@ -18,12 +18,16 @@ import {
   checkSum,
   enableCache,
   githubToken,
+  pyProjectFile,
   pythonVersion,
   toolBinDir,
   toolDir,
-  version,
+  uvFile,
+  version as versionInput,
 } from "./utils/inputs";
 import * as exec from "@actions/exec";
+import fs from "node:fs";
+import { getUvVersionFromConfigFile } from "./utils/pyproject";
 
 async function run(): Promise<void> {
   const platform = getPlatform();
@@ -36,13 +40,7 @@ async function run(): Promise<void> {
     if (arch === undefined) {
       throw new Error(`Unsupported architecture: ${process.arch}`);
     }
-    const setupResult = await setupUv(
-      platform,
-      arch,
-      version,
-      checkSum,
-      githubToken,
-    );
+    const setupResult = await setupUv(platform, arch, checkSum, githubToken);
 
     addUvToPath(setupResult.uvDir);
     addToolBinToPath();
@@ -66,11 +64,10 @@ async function run(): Promise<void> {
 async function setupUv(
   platform: Platform,
   arch: Architecture,
-  versionInput: string,
   checkSum: string | undefined,
   githubToken: string,
 ): Promise<{ uvDir: string; version: string }> {
-  const resolvedVersion = await resolveVersion(versionInput, githubToken);
+  const resolvedVersion = await determineVersion();
   const toolCacheResult = tryGetFromToolCache(arch, resolvedVersion);
   if (toolCacheResult.installedPath) {
     core.info(`Found uv in tool-cache for ${toolCacheResult.version}`);
@@ -94,6 +91,28 @@ async function setupUv(
   };
 }
 
+async function determineVersion(): Promise<string> {
+  if (versionInput !== "") {
+    return await resolveVersion(versionInput, githubToken);
+  }
+  const configFile = uvFile !== "" ? uvFile : pyProjectFile;
+  if (configFile !== "") {
+    const versionFromConfigFile = getUvVersionFromConfigFile(configFile);
+    if (versionFromConfigFile === undefined) {
+      core.warning(
+        `Could not find required-version under [tool.uv] in ${configFile}. Falling back to latest`,
+      );
+    }
+    return await resolveVersion(versionFromConfigFile || "latest", githubToken);
+  }
+  if (!fs.existsSync("uv.toml") && !fs.existsSync("pyproject.toml")) {
+    return await resolveVersion("latest", githubToken);
+  }
+  const versionFile = fs.existsSync("uv.toml") ? "uv.toml" : "pyproject.toml";
+  const versionFromConfigFile = getUvVersionFromConfigFile(versionFile);
+  return await resolveVersion(versionFromConfigFile || "latest", githubToken);
+}
+
 function addUvToPath(cachedPath: string): void {
   core.addPath(cachedPath);
   core.info(`Added ${cachedPath} to the path`);

src/utils/inputs.ts

@@ -2,6 +2,8 @@ import * as core from "@actions/core";
 import path from "node:path";
 
 export const version = core.getInput("version");
+export const pyProjectFile = core.getInput("pyproject-file");
+export const uvFile = core.getInput("uv-file");
 export const pythonVersion = core.getInput("python-version");
 export const checkSum = core.getInput("checksum");
 export const enableCache = getEnableCache();

src/utils/pyproject.ts

@@ -0,0 +1,38 @@
+import fs from "node:fs";
+import * as core from "@actions/core";
+import * as toml from "@iarna/toml";
+
+export function getUvVersionFromConfigFile(
+  filePath: string,
+): string | undefined {
+  if (!fs.existsSync(filePath)) {
+    core.warning(`Could not find file: ${filePath}`);
+    return undefined;
+  }
+  let requiredVersion = getRequiredVersion(filePath);
+
+  if (requiredVersion?.startsWith("==")) {
+    requiredVersion = requiredVersion.slice(2);
+  }
+  if (requiredVersion !== undefined) {
+    core.info(
+      `Found required-version for uv in ${filePath}: ${requiredVersion}`,
+    );
+  }
+  return requiredVersion;
+}
+
+function getRequiredVersion(filePath: string): string | undefined {
+  const fileContent = fs.readFileSync(filePath, "utf-8");
+
+  if (filePath.endsWith("pyproject.toml")) {
+    const tomlContent = toml.parse(fileContent) as {
+      tool?: { uv?: { "required-version"?: string } };
+    };
+    return tomlContent?.tool?.uv?.["required-version"];
+  }
+  const tomlContent = toml.parse(fileContent) as {
+    "required-version"?: string;
+  };
+  return tomlContent["required-version"];
+}