@vercel/python 6.0.4 → 6.0.5

package/dist/index.js

@@ -989,10 +989,10 @@ var require_semver = __commonJS({
       var rangeTmp;
       if (this.operator === "") {
         rangeTmp = new Range(comp.value, options);
-        return satisfies(this.value, rangeTmp, options);
+        return satisfies2(this.value, rangeTmp, options);
       } else if (comp.operator === "") {
         rangeTmp = new Range(this.value, options);
-        return satisfies(comp.semver, rangeTmp, options);
+        return satisfies2(comp.semver, rangeTmp, options);
       }
       var sameDirectionIncreasing = (this.operator === ">=" || this.operator === ">") && (comp.operator === ">=" || comp.operator === ">");
       var sameDirectionDecreasing = (this.operator === "<=" || this.operator === "<") && (comp.operator === "<=" || comp.operator === "<");
@@ -1301,8 +1301,8 @@ var require_semver = __commonJS({
       }
       return true;
     }
-    exports.satisfies = satisfies;
-    function satisfies(version2, range, options) {
+    exports.satisfies = satisfies2;
+    function satisfies2(version2, range, options) {
       try {
         range = new Range(range, options);
       } catch (er) {
@@ -1430,7 +1430,7 @@ var require_semver = __commonJS({
         default:
           throw new TypeError('Must provide a hilo val of "<" or ">"');
       }
-      if (satisfies(version2, range, options)) {
+      if (satisfies2(version2, range, options)) {
         return false;
       }
       for (var i2 = 0; i2 < range.set.length; ++i2) {
@@ -3133,6 +3133,81 @@ function getLatestPythonVersion({
   }
   return selection;
 }
+function parseVersionTuple(input) {
+  const cleaned = input.trim().replace(/\s+/g, "");
+  const m = cleaned.match(/^(\d+)(?:\.(\d+))?/);
+  if (!m)
+    return null;
+  const major = Number(m[1]);
+  const minor = m[2] !== void 0 ? Number(m[2]) : 0;
+  if (Number.isNaN(major) || Number.isNaN(minor))
+    return null;
+  return [major, minor];
+}
+function compareTuples(a, b) {
+  if (a[0] !== b[0])
+    return a[0] - b[0];
+  return a[1] - b[1];
+}
+function parseSpecifier(spec) {
+  const s = spec.trim();
+  const m = s.match(/^(<=|>=|==|!=|~=|<|>)\s*([0-9]+(?:\.[0-9]+)?)(?:\.\*)?$/) || // Bare version like "3.11" -> implied ==
+  s.match(/^()([0-9]+(?:\.[0-9]+)?)(?:\.\*)?$/);
+  if (!m)
+    return null;
+  const op = m[1] || "==";
+  const vt = parseVersionTuple(m[2]);
+  if (!vt)
+    return null;
+  return { op, ver: vt };
+}
+function satisfies(candidate, spec) {
+  const cmp = compareTuples(candidate, spec.ver);
+  switch (spec.op) {
+    case "==":
+      return cmp === 0;
+    case "!=":
+      return cmp !== 0;
+    case "<":
+      return cmp < 0;
+    case "<=":
+      return cmp <= 0;
+    case ">":
+      return cmp > 0;
+    case ">=":
+      return cmp >= 0;
+    case "~=": {
+      const lowerOk = cmp >= 0;
+      const upper = [spec.ver[0], spec.ver[1] + 1];
+      return lowerOk && compareTuples(candidate, upper) < 0;
+    }
+    default:
+      return false;
+  }
+}
+function selectFromRequiresPython(expr) {
+  const raw = expr.trim();
+  if (!raw)
+    return void 0;
+  const parts = raw.split(",").map((p) => p.trim()).filter(Boolean);
+  const specifiers = [];
+  for (const p of parts) {
+    const sp = parseSpecifier(p);
+    if (sp)
+      specifiers.push(sp);
+  }
+  if (specifiers.length === 0) {
+    return allOptions.find((o) => o.version === raw);
+  }
+  const matches = allOptions.filter((opt) => {
+    const vt = parseVersionTuple(opt.version);
+    return specifiers.every((sp) => satisfies(vt, sp));
+  });
+  if (matches.length === 0)
+    return void 0;
+  const installedMatch = matches.find(isInstalled2);
+  return installedMatch ?? matches[0];
+}
 function getSupportedPythonVersion({
   isDev,
   declaredPythonVersion
@@ -3143,7 +3218,12 @@ function getSupportedPythonVersion({
   let selection = getLatestPythonVersion({ isDev: false });
   if (declaredPythonVersion) {
     const { version: version2, source } = declaredPythonVersion;
-    const requested = allOptions.find((o) => o.version === version2);
+    let requested;
+    if (source === "pyproject.toml") {
+      requested = selectFromRequiresPython(version2);
+    } else {
+      requested = allOptions.find((o) => o.version === version2);
+    }
     if (requested) {
       if (isDiscontinued(requested)) {
         throw new import_build_utils2.NowBuildError({
@@ -3920,17 +4000,12 @@ var build = async ({
     } catch (err) {
       (0, import_build_utils7.debug)("Failed to parse pyproject.toml", err);
     }
-    const VERSION_REGEX = /\b\d+\.\d+\b/;
-    const exact = requiresPython?.trim().match(VERSION_REGEX)?.[0];
-    if (exact) {
-      declaredPythonVersion = { version: exact, source: "pyproject.toml" };
-      (0, import_build_utils7.debug)(
-        `Found Python version ${exact} in pyproject.toml (requires-python: "${requiresPython}")`
-      );
-    } else if (requiresPython) {
-      (0, import_build_utils7.debug)(
-        `Could not parse Python version from pyproject.toml requires-python: "${requiresPython}"`
-      );
+    if (typeof requiresPython === "string" && requiresPython.trim()) {
+      declaredPythonVersion = {
+        version: requiresPython.trim(),
+        source: "pyproject.toml"
+      };
+      (0, import_build_utils7.debug)(`Found requires-python "${requiresPython}" in pyproject.toml`);
     }
   } else if (pipfileLockDir) {
     let lock = {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/python",
-  "version": "6.0.4",
+  "version": "6.0.5",
   "main": "./dist/index.js",
   "license": "Apache-2.0",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/python",