pyfig 0.4.0 → 0.5.0

package/dist/cjs/sync-resolver.js

@@ -74,7 +74,7 @@ var import_node_os = __toESM(require("node:os"), 1);
 var import_node_path5 = __toESM(require("node:path"), 1);
 var import_node_stream = require("node:stream");
 var import_promises2 = require("node:stream/promises");
-var import_extract_zip = __toESM(require("extract-zip"), 1);
+var import_fflate = require("fflate");
 var tar = __toESM(require("tar"), 1);
 var import_undici = require("undici");
 
@@ -105,8 +105,20 @@ function* ancestors(startDirectory) {
   }
 }
 
+// src/python-version.ts
+var import_pep440 = require("@renovatebot/pep440");
+function isValidPythonSpecifier(specifier) {
+  return import_pep440.validRange(specifier);
+}
+function isValidPythonVersion(version) {
+  return import_pep440.valid(version) !== null;
+}
+function pythonVersionSatisfies(version, specifier) {
+  return import_pep440.filter([version], specifier).length === 1;
+}
+
 // src/config.ts
-var DEFAULT_PYTHON_RANGE = ">=3.10.0 <4.0.0";
+var DEFAULT_REQUIRES_PYTHON = ">=3.10,<4";
 var DEFAULT_MANAGED_PYTHON = "3.12";
 var DEFAULT_UV_VERSION = "0.13.6";
 var DEFAULT_UV_RANGE = ">=0.10.0 <1.0.0";
@@ -122,13 +134,13 @@ var envPathsFunction = (() => {
 })();
 function resolveOptions(options = {}) {
   const env = { ...options.env ?? process.env };
-  const pythonRange = options.pythonRange ?? env["PYFIG_PYTHON_RANGE"] ?? DEFAULT_PYTHON_RANGE;
+  const requiresPython = options.requiresPython ?? env["PYFIG_REQUIRES_PYTHON"] ?? DEFAULT_REQUIRES_PYTHON;
   const uvRange = options.uvRange ?? env["PYFIG_UV_RANGE"] ?? DEFAULT_UV_RANGE;
-  assertRange("Python", pythonRange);
+  assertPythonSpecifier(requiresPython);
   assertRange("uv", uvRange);
   const managedPython = options.managedPython ?? env["PYFIG_MANAGED_PYTHON"] ?? DEFAULT_MANAGED_PYTHON;
   const uvVersion = options.uvVersion ?? env["PYFIG_UV_VERSION"] ?? DEFAULT_UV_VERSION;
-  assertManagedPythonRequest(managedPython, pythonRange);
+  assertManagedPythonRequest(managedPython, requiresPython);
   assertUvVersion(uvVersion, uvRange);
   const probeTimeoutMs = resolveDuration("probeTimeoutMs", options.probeTimeoutMs, env["PYFIG_PROBE_TIMEOUT_MS"], DEFAULT_PROBE_TIMEOUT_MS);
   const installTimeoutMs = resolveDuration("installTimeoutMs", options.installTimeoutMs, env["PYFIG_INSTALL_TIMEOUT_MS"], DEFAULT_INSTALL_TIMEOUT_MS);
@@ -141,7 +153,7 @@ function resolveOptions(options = {}) {
   const autoInstall = options.autoInstall ?? parseBoolean(env["PYFIG_AUTO_INSTALL"], true);
   return {
     python: options.python ?? env["PYFIG_PYTHON"] ?? "",
-    pythonRange,
+    requiresPython,
     managedPython,
     uvVersion,
     uvRange,
@@ -182,14 +194,19 @@ function assertUvVersion(version, range) {
     throw new TypeError(`Pinned uv ${version} does not satisfy supported range ${range}.`);
   }
 }
-function assertManagedPythonRequest(request, pythonRange) {
+function assertPythonSpecifier(specifier) {
+  if (!isValidPythonSpecifier(specifier)) {
+    throw new TypeError(`Invalid requires-python PEP 440 specifier: ${specifier}`);
+  }
+}
+function assertManagedPythonRequest(request, requiresPython) {
   if (!request || /[\\/\0\r\n]/u.test(request) || request.includes("..")) {
     throw new TypeError(`Invalid managed Python request: ${request}`);
   }
   if (/^\d+\.\d+(?:\.\d+)?$/u.test(request)) {
     const normalized = request.split(".").length === 2 ? `${request}.0` : request;
-    if (!import_semver.default.satisfies(normalized, pythonRange)) {
-      throw new TypeError(`Managed Python ${request} cannot satisfy configured range ${pythonRange}.`);
+    if (!pythonVersionSatisfies(normalized, requiresPython)) {
+      throw new TypeError(`Managed Python ${request} cannot satisfy requires-python ${requiresPython}.`);
     }
   }
 }
@@ -497,7 +514,15 @@ if os.path.isfile(header_path) and library_path:
     }
 
 release_level = sys.version_info.releaselevel
-release_suffix = "" if release_level == "final" else f"-{release_level}.{sys.version_info.serial}"
+release_suffixes = {
+    "alpha": "a",
+    "beta": "b",
+    "candidate": "rc",
+    "final": "",
+}
+release_suffix = release_suffixes[release_level]
+if release_suffix:
+    release_suffix += str(sys.version_info.serial)
 
 print(json.dumps({
     "executable": sys.executable,
@@ -517,8 +542,8 @@ print(json.dumps({
     "embedding": embedding,
 }))
 `;
-function pythonSatisfiesRequirements(python, options) {
-  return import_semver2.default.satisfies(python.version, options.pythonRange) && (!options.requireEmbedding || python.implementation === "cpython" && python.embedding !== null && pythonArchitectureMatchesRuntime(python)) && (!options.requireGil || !python.gilDisabled);
+function pythonSatisfiesPolicy(python, options) {
+  return pythonVersionSatisfies(python.version, options.requiresPython) && (!options.requireEmbedding || python.implementation === "cpython" && python.embedding !== null && pythonArchitectureMatchesRuntime(python)) && (!options.requireGil || !python.gilDisabled);
 }
 async function probePython(candidate, options) {
   const executable = await resolveExecutable(candidate.executable, options.env);
@@ -527,7 +552,7 @@ async function probePython(candidate, options) {
   try {
     const { stdout } = run(executable, [...candidate.args, "-c", PYTHON_PROBE], options.env, options.probeTimeoutMs);
     const info = JSON.parse(stdout.trim());
-    return import_semver2.default.valid(info.version) ? info : null;
+    return isValidPythonVersion(info.version) ? info : null;
   } catch {
     return null;
   }
@@ -570,14 +595,14 @@ function pythonArchitectureMatchesRuntime(python) {
 async function ensureUv(options = {}) {
   return ensureUvResolved(resolveOptions(options));
 }
-async function ensureEnvironment(options = {}, requirements = [], dependencyOptions = {}) {
+async function ensureEnvironment(options = {}, dependencies = [], dependencyOptions = {}) {
   const resolved = resolveOptions(options);
-  const normalized = normalizeRequirements(requirements);
+  const normalized = normalizeDependencies(dependencies);
   const selections = normalizeDependencyOptions(dependencyOptions);
   const uv = await ensureUvResolved(resolved);
   const python = await ensureVirtualEnvironmentResolved(resolved, uv);
   if (normalized.length > 0 || selections.extras.length > 0 || selections.groups.length > 0 || selections.allExtras) {
-    await installRuntimeRequirements(uv, python, normalized, selections, resolved);
+    await installRuntimeDependencies(uv, python, normalized, selections, resolved);
   }
   return {
     python,
@@ -592,7 +617,7 @@ async function ensureVirtualEnvironmentResolved(options, uv) {
   const directory = virtualEnvironmentDirectory(options.projectRoot);
   const check = async () => {
     const candidate = await inspectVirtualEnvironment(directory, options);
-    return candidate && pythonSatisfiesRequirements(candidate, options) && await virtualEnvironmentMatchesConfiguredPython(candidate, options) ? candidate : null;
+    return candidate && pythonSatisfiesPolicy(candidate, options) && await virtualEnvironmentMatchesConfiguredPython(candidate, options) ? candidate : null;
   };
   if (!options.createVirtualEnvironment) {
     throw new Error(`No compatible environment is available and creation is disabled. ` + `Pyfig would create ${directory}.`);
@@ -625,7 +650,7 @@ async function ensureVirtualEnvironmentResolved(options, uv) {
 async function findReusableEnvironment(options) {
   if (options.python) {
     const configured = await probePython({ executable: options.python, args: [] }, options);
-    if (!configured || !pythonSatisfiesRequirements(configured, options)) {
+    if (!configured || !pythonSatisfiesPolicy(configured, options)) {
       throw incompatibleConfiguredPython(options);
     }
     if (configured.virtualEnvironment)
@@ -636,7 +661,7 @@ async function findReusableEnvironment(options) {
     virtualEnvironmentDirectory(options.projectRoot)
   ]) {
     const info = await inspectVirtualEnvironment(directory, options);
-    if (info && pythonSatisfiesRequirements(info, options) && await virtualEnvironmentMatchesConfiguredPython(info, options)) {
+    if (info && pythonSatisfiesPolicy(info, options) && await virtualEnvironmentMatchesConfiguredPython(info, options)) {
       return info;
     }
   }
@@ -645,13 +670,13 @@ async function findReusableEnvironment(options) {
 async function ensureBasePythonResolved(uv, options) {
   if (options.python) {
     const configured = await probePython({ executable: options.python, args: [] }, options);
-    if (!configured || !pythonSatisfiesRequirements(configured, options)) {
+    if (!configured || !pythonSatisfiesPolicy(configured, options)) {
       throw incompatibleConfiguredPython(options);
     }
     if (!configured.virtualEnvironment)
       return configured;
     const base = await probePython({ executable: configured.baseExecutable, args: [] }, options);
-    if (base && pythonSatisfiesRequirements(base, options))
+    if (base && pythonSatisfiesPolicy(base, options))
       return base;
     throw incompatibleConfiguredPython(options);
   }
@@ -693,7 +718,7 @@ async function findPythonWithUv(uv, options, source) {
     try {
       const { stdout } = await runAsync(uv.executable, args, explicitPythonSourceEnvironment(options), options.probeTimeoutMs);
       const info = await probePython({ executable: stdout.trim(), args: [] }, options);
-      if (info && pythonSatisfiesRequirements(info, options))
+      if (info && pythonSatisfiesPolicy(info, options))
         return info;
     } catch {}
   }
@@ -711,7 +736,7 @@ async function findPythonWithUv(uv, options, source) {
     const candidates = installedPythonPaths(stdout);
     for (const executable of candidates) {
       const info = await probePython({ executable, args: [] }, options);
-      if (info && !info.virtualEnvironment && pythonSatisfiesRequirements(info, options)) {
+      if (info && !info.virtualEnvironment && pythonSatisfiesPolicy(info, options)) {
         return info;
       }
     }
@@ -735,7 +760,7 @@ async function inspectVirtualEnvironment(directory, options) {
   const info = await probePython({ executable, args: [] }, options);
   return info?.virtualEnvironment && pathsEqual(info.virtualEnvironment, directory) ? info : null;
 }
-async function installRuntimeRequirements(uv, python, requirements, dependencyOptions, options) {
+async function installRuntimeDependencies(uv, python, dependencies, dependencyOptions, options) {
   if (!python.virtualEnvironment) {
     throw new Error("Runtime dependency installation requires a virtual environment.");
   }
@@ -744,18 +769,18 @@ async function installRuntimeRequirements(uv, python, requirements, dependencyOp
     timeoutMs: options.coordinationTimeoutMs,
     check: async () => null,
     mutate: async () => {
-      const temporary = await import_promises.mkdtemp(import_node_path5.default.join(import_node_os.default.tmpdir(), "pyfig-requirements-"));
+      const temporary = await import_promises.mkdtemp(import_node_path5.default.join(import_node_os.default.tmpdir(), "pyfig-dependencies-"));
       try {
-        const additions = import_node_path5.default.join(temporary, "runtime-requirements.txt");
-        const resolved = import_node_path5.default.join(temporary, "resolved-requirements.txt");
+        const additions = import_node_path5.default.join(temporary, "runtime-dependencies.txt");
+        const resolved = import_node_path5.default.join(temporary, "resolved-dependencies.txt");
         const pyproject = import_node_path5.default.join(options.projectRoot, "pyproject.toml");
         const hasPyproject = import_node_fs4.default.existsSync(pyproject);
         if (!hasPyproject && (dependencyOptions.extras.length > 0 || dependencyOptions.groups.length > 0 || dependencyOptions.allExtras)) {
           throw new Error("Runtime extras and groups require an existing pyproject.toml.");
         }
         const sources = hasPyproject ? [pyproject] : [];
-        if (requirements.length > 0) {
-          await import_promises.writeFile(additions, `${requirements.join(`
+        if (dependencies.length > 0) {
+          await import_promises.writeFile(additions, `${dependencies.join(`
 `)}
 `, "utf8");
           sources.push(additions);
@@ -814,11 +839,11 @@ async function findAvailableUv(options) {
   const managed = probeUv(uvExecutable(options), options);
   return managed?.version === options.uvVersion ? managed : null;
 }
-function normalizeRequirements(requirements) {
-  const normalized = requirements.map((requirement) => requirement.trim());
-  for (const requirement of normalized) {
-    if (!requirement || /[\0\r\n]/u.test(requirement)) {
-      throw new TypeError(`Invalid runtime requirement: ${JSON.stringify(requirement)}`);
+function normalizeDependencies(dependencies) {
+  const normalized = dependencies.map((dependency) => dependency.trim());
+  for (const dependency of normalized) {
+    if (!dependency || /[\0\r\n]/u.test(dependency)) {
+      throw new TypeError(`Invalid runtime dependency: ${JSON.stringify(dependency)}`);
     }
   }
   return [...new Set(normalized)];
@@ -855,17 +880,17 @@ function targetUvEnvironment(options, python) {
   return uvCommandEnvironment(uvEnvironment(options), python);
 }
 function incompatibleConfiguredPython(options) {
-  return new Error(`Configured Python ${options.python} is unavailable or does not satisfy ` + `${options.pythonRange}${options.requireEmbedding ? " with CPython embedding files" : ""}.`);
+  return new Error(`Configured Python ${options.python} is unavailable or does not satisfy ` + `requires-python ${options.requiresPython}` + `${options.requireEmbedding ? " with CPython embedding files" : ""}.`);
 }
 function missingPythonMessage(options, reason) {
   const embedding = options.requireEmbedding ? " with compatible CPython headers, library, architecture, and GIL ABI" : "";
-  return `No Python satisfies ${options.pythonRange}${embedding}; ${reason}.`;
+  return `No Python satisfies requires-python ${options.requiresPython}${embedding}; ${reason}.`;
 }
 async function virtualEnvironmentMatchesConfiguredPython(virtualEnvironment, options) {
   if (!options.python)
     return true;
   const configured = await probePython({ executable: options.python, args: [] }, options);
-  if (!configured || !pythonSatisfiesRequirements(configured, options))
+  if (!configured || !pythonSatisfiesPolicy(configured, options))
     return false;
   if (configured.virtualEnvironment && pathsEqual(configured.executable, virtualEnvironment.executable)) {
     return true;
@@ -894,11 +919,7 @@ async function installUv(installDir, options) {
     }
     const extracted = import_node_path5.default.join(temporary, "extracted");
     await import_promises.mkdir(extracted, { recursive: true });
-    if (asset.endsWith(".zip"))
-      await import_extract_zip.default(archive, { dir: extracted });
-    else
-      await tar.x({ file: archive, cwd: extracted, strict: true });
-    const source = await findFile(extracted, process.platform === "win32" ? "uv.exe" : "uv");
+    const source = await extractUvExecutable(archive, asset, extracted);
     if (!source)
       throw new Error(`uv archive did not contain the expected executable: ${asset}`);
     await publishUvAtomically(source, installDir, options);
@@ -907,6 +928,22 @@ async function installUv(installDir, options) {
     await import_promises.rm(temporary, { recursive: true, force: true });
   }
 }
+async function extractUvExecutable(archive, asset, destination) {
+  const executableName = process.platform === "win32" ? "uv.exe" : "uv";
+  if (!asset.endsWith(".zip")) {
+    await tar.x({ file: archive, cwd: destination, strict: true });
+    return findFile(destination, executableName);
+  }
+  const entries = import_fflate.unzipSync(await import_promises.readFile(archive), {
+    filter: ({ name }) => import_node_path5.default.posix.basename(name.replaceAll("\\", "/")) === executableName
+  });
+  const matches = Object.entries(entries).filter(([name]) => import_node_path5.default.posix.basename(name.replaceAll("\\", "/")) === executableName);
+  if (matches.length !== 1 || !matches[0])
+    return null;
+  const source = import_node_path5.default.join(destination, executableName);
+  await import_promises.writeFile(source, matches[0][1], { flag: "wx" });
+  return source;
+}
 async function publishUvAtomically(source, installDir, options) {
   await import_promises.mkdir(installDir, { recursive: true });
   const executable = uvExecutable(options);
@@ -1008,4 +1045,4 @@ main().catch((error) => {
   process.exitCode = 1;
 });
 
-//# debugId=450BD20294AA111B64756E2164756E21
+//# debugId=8D6E1E9C1BFA227064756E2164756E21