@vercel/python 6.0.3 → 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) {
@@ -2751,7 +2751,7 @@ module.exports = __toCommonJS(src_exports);
 var import_fs5 = __toESM(require("fs"));
 var import_util = require("util");
 var import_path5 = require("path");
-var import_build_utils6 = require("@vercel/build-utils");
+var import_build_utils7 = require("@vercel/build-utils");
 
 // src/install.ts
 var import_execa = __toESM(require_execa());
@@ -3071,7 +3071,7 @@ async function exportRequirementsFromPipfile({
 }
 
 // src/index.ts
-var import_build_utils7 = require("@vercel/build-utils");
+var import_build_utils8 = require("@vercel/build-utils");
 
 // src/version.ts
 var import_build_utils2 = require("@vercel/build-utils");
@@ -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({
@@ -3204,7 +3284,7 @@ function isInstalled2({ pipPath, pythonPath }) {
 var import_child_process = require("child_process");
 var import_fs4 = require("fs");
 var import_path4 = require("path");
-var import_build_utils5 = require("@vercel/build-utils");
+var import_build_utils6 = require("@vercel/build-utils");
 
 // src/entrypoint.ts
 var import_fs2 = __toESM(require("fs"));
@@ -3334,6 +3414,8 @@ async function detectPythonEntrypoint(framework, workPath, configuredEntrypoint)
 // src/utils.ts
 var import_fs3 = __toESM(require("fs"));
 var import_path3 = require("path");
+var import_execa2 = __toESM(require_execa());
+var import_build_utils5 = require("@vercel/build-utils");
 var isInVirtualEnv = () => {
   return process.env.VIRTUAL_ENV;
 };
@@ -3354,6 +3436,51 @@ function useVirtualEnv(workPath, env, systemPython) {
   }
   return { pythonCmd };
 }
+async function runPyprojectScript(workPath, scriptNames, env) {
+  const pyprojectPath = (0, import_path3.join)(workPath, "pyproject.toml");
+  if (!import_fs3.default.existsSync(pyprojectPath))
+    return false;
+  let pyproject = null;
+  try {
+    pyproject = await (0, import_build_utils5.readConfigFile)(pyprojectPath);
+  } catch {
+    console.error("Failed to parse pyproject.toml");
+    return false;
+  }
+  const scripts = pyproject?.tool?.vercel?.scripts || {};
+  const candidates = typeof scriptNames === "string" ? [scriptNames] : Array.from(scriptNames);
+  const scriptToRun = candidates.find((name) => Boolean(scripts[name]));
+  if (!scriptToRun)
+    return false;
+  const systemPython = process.platform === "win32" ? "python" : "python3";
+  const finalEnv = { ...process.env, ...env };
+  const { pythonCmd } = useVirtualEnv(workPath, finalEnv, systemPython);
+  const uvPath = await getUvBinaryOrInstall(pythonCmd);
+  const scriptCommand = scripts[scriptToRun];
+  if (typeof scriptCommand === "string" && scriptCommand.trim()) {
+    const uvDir = (0, import_path3.dirname)(uvPath);
+    finalEnv.PATH = `${uvDir}${import_path3.delimiter}${finalEnv.PATH || ""}`;
+    if (/^\s*uv(\s|$)/i.test(scriptCommand)) {
+      console.log(`Executing: ${scriptCommand}`);
+      await (0, import_build_utils5.execCommand)(scriptCommand, {
+        cwd: workPath,
+        env: finalEnv
+      });
+      return true;
+    }
+    const args = process.platform === "win32" ? ["run", "cmd", "/d", "/s", "/c", scriptCommand] : ["run", "sh", "-lc", scriptCommand];
+    console.log(
+      `Executing: ${uvPath} ${args.map((a) => /\s/.test(a) ? `"${a.replace(/"/g, '\\"')}"` : a).join(" ")}`
+    );
+    await (0, import_execa2.default)(uvPath, args, {
+      cwd: workPath,
+      stdio: "inherit",
+      env: finalEnv
+    });
+    return true;
+  }
+  return false;
+}
 
 // src/start-dev-server.ts
 function silenceNodeWarnings() {
@@ -3398,12 +3525,12 @@ function installGlobalCleanupHandlers() {
       try {
         process.kill(info.pid, "SIGTERM");
       } catch (err) {
-        (0, import_build_utils5.debug)(`Error sending SIGTERM to ${info.pid}: ${err}`);
+        (0, import_build_utils6.debug)(`Error sending SIGTERM to ${info.pid}: ${err}`);
       }
       try {
         process.kill(info.pid, "SIGKILL");
       } catch (err) {
-        (0, import_build_utils5.debug)(`Error sending SIGKILL to ${info.pid}: ${err}`);
+        (0, import_build_utils6.debug)(`Error sending SIGKILL to ${info.pid}: ${err}`);
       }
       PERSISTENT_SERVERS.delete(key);
     }
@@ -3411,7 +3538,7 @@ function installGlobalCleanupHandlers() {
       try {
         restoreWarnings();
       } catch (err) {
-        (0, import_build_utils5.debug)(`Error restoring warnings: ${err}`);
+        (0, import_build_utils6.debug)(`Error restoring warnings: ${err}`);
       }
       restoreWarnings = null;
     }
@@ -3437,10 +3564,10 @@ function createDevAsgiShim(workPath, modulePath) {
     const template = (0, import_fs4.readFileSync)(templatePath, "utf8");
     const shimSource = template.replace(/__VC_DEV_MODULE_PATH__/g, modulePath);
     (0, import_fs4.writeFileSync)(shimPath, shimSource, "utf8");
-    (0, import_build_utils5.debug)(`Prepared Python dev static shim at ${shimPath}`);
+    (0, import_build_utils6.debug)(`Prepared Python dev static shim at ${shimPath}`);
     return ASGI_SHIM_MODULE;
   } catch (err) {
-    (0, import_build_utils5.debug)(`Failed to prepare dev static shim: ${err?.message || err}`);
+    (0, import_build_utils6.debug)(`Failed to prepare dev static shim: ${err?.message || err}`);
     return null;
   }
 }
@@ -3453,10 +3580,10 @@ function createDevWsgiShim(workPath, modulePath) {
     const template = (0, import_fs4.readFileSync)(templatePath, "utf8");
     const shimSource = template.replace(/__VC_DEV_MODULE_PATH__/g, modulePath);
     (0, import_fs4.writeFileSync)(shimPath, shimSource, "utf8");
-    (0, import_build_utils5.debug)(`Prepared Python dev WSGI shim at ${shimPath}`);
+    (0, import_build_utils6.debug)(`Prepared Python dev WSGI shim at ${shimPath}`);
     return WSGI_SHIM_MODULE;
   } catch (err) {
-    (0, import_build_utils5.debug)(`Failed to prepare dev WSGI shim: ${err?.message || err}`);
+    (0, import_build_utils6.debug)(`Failed to prepare dev WSGI shim: ${err?.message || err}`);
     return null;
   }
 }
@@ -3476,7 +3603,7 @@ var startDevServer = async (opts) => {
   );
   if (!entry) {
     const searched = framework === "fastapi" ? FASTAPI_CANDIDATE_ENTRYPOINTS.join(", ") : FLASK_CANDIDATE_ENTRYPOINTS.join(", ");
-    throw new import_build_utils5.NowBuildError({
+    throw new import_build_utils6.NowBuildError({
       code: "PYTHON_ENTRYPOINT_NOT_FOUND",
       message: `No ${framework} entrypoint found. Define a valid application entrypoint in one of the following locations: ${searched} or add an 'app' script in pyproject.toml.`,
       link: `https://vercel.com/docs/frameworks/backend/${framework?.toLowerCase()}#exporting-the-${framework?.toLowerCase()}-application`,
@@ -3526,7 +3653,7 @@ var startDevServer = async (opts) => {
       let pythonCmd = systemPython;
       const venv = isInVirtualEnv();
       if (venv) {
-        (0, import_build_utils5.debug)(`Running in virtualenv at ${venv}`);
+        (0, import_build_utils6.debug)(`Running in virtualenv at ${venv}`);
       } else {
         const { pythonCmd: venvPythonCmd, venvRoot } = useVirtualEnv(
           workPath,
@@ -3535,9 +3662,9 @@ var startDevServer = async (opts) => {
         );
         pythonCmd = venvPythonCmd;
         if (venvRoot) {
-          (0, import_build_utils5.debug)(`Using virtualenv at ${venvRoot}`);
+          (0, import_build_utils6.debug)(`Using virtualenv at ${venvRoot}`);
         } else {
-          (0, import_build_utils5.debug)("No virtualenv found");
+          (0, import_build_utils6.debug)("No virtualenv found");
           try {
             const yellow = "\x1B[33m";
             const reset = "\x1B[0m";
@@ -3560,7 +3687,7 @@ If you are using a virtual environment, activate it before running "vercel dev",
         }
         const moduleToRun = devShimModule || modulePath;
         const argv = ["-u", "-m", moduleToRun];
-        (0, import_build_utils5.debug)(`Starting ASGI dev server: ${pythonCmd} ${argv.join(" ")}`);
+        (0, import_build_utils6.debug)(`Starting ASGI dev server: ${pythonCmd} ${argv.join(" ")}`);
         const child = (0, import_child_process.spawn)(pythonCmd, argv, {
           cwd: workPath,
           env,
@@ -3638,7 +3765,7 @@ If you are using a virtual environment, activate it before running "vercel dev",
         }
         const moduleToRun = devShimModule || modulePath;
         const argv = ["-u", "-m", moduleToRun];
-        (0, import_build_utils5.debug)(`Starting Flask dev server: ${pythonCmd} ${argv.join(" ")}`);
+        (0, import_build_utils6.debug)(`Starting Flask dev server: ${pythonCmd} ${argv.join(" ")}`);
         const child = (0, import_child_process.spawn)(pythonCmd, argv, {
           cwd: workPath,
           env,
@@ -3748,13 +3875,13 @@ async function downloadFilesInWorkPath({
   files,
   meta = {}
 }) {
-  (0, import_build_utils6.debug)("Downloading user files...");
-  let downloadedFiles = await (0, import_build_utils6.download)(files, workPath, meta);
+  (0, import_build_utils7.debug)("Downloading user files...");
+  let downloadedFiles = await (0, import_build_utils7.download)(files, workPath, meta);
   if (meta.isDev) {
     const { devCacheDir = (0, import_path5.join)(workPath, ".now", "cache") } = meta;
     const destCache = (0, import_path5.join)(devCacheDir, (0, import_path5.basename)(entrypoint, ".py"));
-    await (0, import_build_utils6.download)(downloadedFiles, destCache);
-    downloadedFiles = await (0, import_build_utils6.glob)("**", destCache);
+    await (0, import_build_utils7.download)(downloadedFiles, destCache);
+    downloadedFiles = await (0, import_build_utils7.glob)("**", destCache);
     workPath = destCache;
   }
   return workPath;
@@ -3782,7 +3909,50 @@ var build = async ({
     console.log('Failed to create "setup.cfg" file');
     throw err;
   }
-  let fsFiles = await (0, import_build_utils6.glob)("**", workPath);
+  if (framework === "fastapi" || framework === "flask") {
+    const {
+      cliType,
+      lockfileVersion,
+      packageJsonPackageManager,
+      turboSupportsCorepackHome
+    } = await (0, import_build_utils7.scanParentDirs)(workPath, true);
+    const spawnEnv = (0, import_build_utils7.getEnvForPackageManager)({
+      cliType,
+      lockfileVersion,
+      packageJsonPackageManager,
+      env: process.env,
+      turboSupportsCorepackHome,
+      projectCreatedAt: config?.projectSettings?.createdAt
+    });
+    const installCommand = config?.projectSettings?.installCommand;
+    if (typeof installCommand === "string") {
+      if (installCommand.trim()) {
+        console.log(`Running "install" command: \`${installCommand}\`...`);
+        await (0, import_build_utils7.execCommand)(installCommand, {
+          env: spawnEnv,
+          cwd: workPath
+        });
+      } else {
+        console.log('Skipping "install" command...');
+      }
+    }
+    const projectBuildCommand = config?.projectSettings?.buildCommand ?? // fallback if provided directly on config (some callers set this)
+    config?.buildCommand;
+    if (projectBuildCommand) {
+      console.log(`Running "${projectBuildCommand}"`);
+      await (0, import_build_utils7.execCommand)(projectBuildCommand, {
+        env: spawnEnv,
+        cwd: workPath
+      });
+    } else {
+      await runPyprojectScript(
+        workPath,
+        ["vercel-build", "now-build", "build"],
+        spawnEnv
+      );
+    }
+  }
+  let fsFiles = await (0, import_build_utils7.glob)("**", workPath);
   if ((framework === "fastapi" || framework === "flask") && (!fsFiles[entrypoint] || !entrypoint.endsWith(".py"))) {
     const detected = await detectPythonEntrypoint(
       config.framework,
@@ -3790,13 +3960,13 @@ var build = async ({
       entrypoint
     );
     if (detected) {
-      (0, import_build_utils6.debug)(
+      (0, import_build_utils7.debug)(
         `Resolved Python entrypoint to "${detected}" (configured "${entrypoint}" not found).`
       );
       entrypoint = detected;
     } else {
       const searchedList = framework === "fastapi" ? FASTAPI_CANDIDATE_ENTRYPOINTS.join(", ") : FLASK_CANDIDATE_ENTRYPOINTS.join(", ");
-      throw new import_build_utils6.NowBuildError({
+      throw new import_build_utils7.NowBuildError({
         code: `${framework.toUpperCase()}_ENTRYPOINT_NOT_FOUND`,
         message: `No ${framework} entrypoint found. Define a valid application entrypoint in one of the following locations: ${searchedList} or add an 'app' script in pyproject.toml.`,
         link: `https://vercel.com/docs/frameworks/backend/${framework}#exporting-the-${framework}-application`,
@@ -3825,22 +3995,17 @@ var build = async ({
   if (pyprojectDir) {
     let requiresPython;
     try {
-      const pyproject = await (0, import_build_utils7.readConfigFile)((0, import_path5.join)(pyprojectDir, "pyproject.toml"));
+      const pyproject = await (0, import_build_utils8.readConfigFile)((0, import_path5.join)(pyprojectDir, "pyproject.toml"));
       requiresPython = pyproject?.project?.["requires-python"];
     } catch (err) {
-      (0, import_build_utils6.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_utils6.debug)(
-        `Found Python version ${exact} in pyproject.toml (requires-python: "${requiresPython}")`
-      );
-    } else if (requiresPython) {
-      (0, import_build_utils6.debug)(
-        `Could not parse Python version from pyproject.toml requires-python: "${requiresPython}"`
-      );
+      (0, import_build_utils7.debug)("Failed to parse pyproject.toml", err);
+    }
+    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 = {};
@@ -3848,7 +4013,7 @@ var build = async ({
       const json = await readFile((0, import_path5.join)(pipfileLockDir, "Pipfile.lock"), "utf8");
       lock = JSON.parse(json);
     } catch (err) {
-      throw new import_build_utils6.NowBuildError({
+      throw new import_build_utils7.NowBuildError({
         code: "INVALID_PIPFILE_LOCK",
         message: "Unable to parse Pipfile.lock"
       });
@@ -3856,14 +4021,14 @@ var build = async ({
     const pyFromLock = lock?._meta?.requires?.python_version;
     if (pyFromLock) {
       declaredPythonVersion = { version: pyFromLock, source: "Pipfile.lock" };
-      (0, import_build_utils6.debug)(`Found Python version ${pyFromLock} in Pipfile.lock`);
+      (0, import_build_utils7.debug)(`Found Python version ${pyFromLock} in Pipfile.lock`);
     }
   }
   const pythonVersion = getSupportedPythonVersion({
     isDev: meta.isDev,
     declaredPythonVersion
   });
-  fsFiles = await (0, import_build_utils6.glob)("**", workPath);
+  fsFiles = await (0, import_build_utils7.glob)("**", workPath);
   const requirementsTxt = (0, import_path5.join)(entryDirectory, "requirements.txt");
   const vendorBaseDir = (0, import_path5.join)(
     workPath,
@@ -3908,7 +4073,7 @@ var build = async ({
         `uv is required for this project but failed to install: ${err instanceof Error ? err.message : String(err)}`
       );
     }
-    (0, import_build_utils6.debug)("Failed to install uv", err);
+    (0, import_build_utils7.debug)("Failed to install uv", err);
   }
   await installRequirement({
     pythonPath: pythonVersion.pythonPath,
@@ -3934,7 +4099,7 @@ var build = async ({
   }
   let installedFromProjectFiles = false;
   if (uvLockDir) {
-    (0, import_build_utils6.debug)('Found "uv.lock"');
+    (0, import_build_utils7.debug)('Found "uv.lock"');
     if (pyprojectDir) {
       const exportedReq = await exportRequirementsFromUv(pyprojectDir, uvPath, {
         locked: true
@@ -3950,10 +4115,10 @@ var build = async ({
       });
       installedFromProjectFiles = true;
     } else {
-      (0, import_build_utils6.debug)('Skipping uv export because "pyproject.toml" was not found');
+      (0, import_build_utils7.debug)('Skipping uv export because "pyproject.toml" was not found');
     }
   } else if (pyprojectDir) {
-    (0, import_build_utils6.debug)('Found "pyproject.toml"');
+    (0, import_build_utils7.debug)('Found "pyproject.toml"');
     if (hasReqLocal || hasReqGlobal) {
       console.log(
         "Detected both pyproject.toml and requirements.txt but no lockfile; using pyproject.toml"
@@ -3973,9 +4138,9 @@ var build = async ({
     });
     installedFromProjectFiles = true;
   } else if (pipfileLockDir || pipfileDir) {
-    (0, import_build_utils6.debug)(`Found ${pipfileLockDir ? '"Pipfile.lock"' : '"Pipfile"'}`);
+    (0, import_build_utils7.debug)(`Found ${pipfileLockDir ? '"Pipfile.lock"' : '"Pipfile"'}`);
     if (hasReqLocal || hasReqGlobal) {
-      (0, import_build_utils6.debug)('Skipping Pipfile export because "requirements.txt" exists');
+      (0, import_build_utils7.debug)('Skipping Pipfile export because "requirements.txt" exists');
     } else {
       const exportedReq = await exportRequirementsFromPipfile({
         pythonPath: pythonVersion.pythonPath,
@@ -3997,7 +4162,7 @@ var build = async ({
     }
   }
   if (!installedFromProjectFiles && fsFiles[requirementsTxt]) {
-    (0, import_build_utils6.debug)('Found local "requirements.txt"');
+    (0, import_build_utils7.debug)('Found local "requirements.txt"');
     const requirementsTxtPath = fsFiles[requirementsTxt].fsPath;
     await installRequirementsFile({
       pythonPath: pythonVersion.pythonPath,
@@ -4009,7 +4174,7 @@ var build = async ({
       meta
     });
   } else if (!installedFromProjectFiles && fsFiles["requirements.txt"]) {
-    (0, import_build_utils6.debug)('Found global "requirements.txt"');
+    (0, import_build_utils7.debug)('Found global "requirements.txt"');
     const requirementsTxtPath = fsFiles["requirements.txt"].fsPath;
     await installRequirementsFile({
       pythonPath: pythonVersion.pythonPath,
@@ -4023,12 +4188,12 @@ var build = async ({
   }
   const originalPyPath = (0, import_path5.join)(__dirname, "..", "vc_init.py");
   const originalHandlerPyContents = await readFile(originalPyPath, "utf8");
-  (0, import_build_utils6.debug)("Entrypoint is", entrypoint);
+  (0, import_build_utils7.debug)("Entrypoint is", entrypoint);
   const moduleName = entrypoint.replace(/\//g, ".").replace(/\.py$/i, "");
   const vendorDir = resolveVendorDir();
   const suffix = meta.isDev && !entrypoint.endsWith(".py") ? ".py" : "";
   const entrypointWithSuffix = `${entrypoint}${suffix}`;
-  (0, import_build_utils6.debug)("Entrypoint with suffix is", entrypointWithSuffix);
+  (0, import_build_utils7.debug)("Entrypoint with suffix is", entrypointWithSuffix);
   const handlerPyContents = originalHandlerPyContents.replace(/__VC_HANDLER_MODULE_NAME/g, moduleName).replace(/__VC_HANDLER_ENTRYPOINT/g, entrypointWithSuffix).replace(/__VC_HANDLER_VENDOR_DIR/g, vendorDir);
   const predefinedExcludes = [
     ".git/**",
@@ -4054,11 +4219,11 @@ var build = async ({
     cwd: workPath,
     ignore: config && typeof config.excludeFiles === "string" ? [...predefinedExcludes, config.excludeFiles] : predefinedExcludes
   };
-  const files = await (0, import_build_utils6.glob)("**", globOptions);
+  const files = await (0, import_build_utils7.glob)("**", globOptions);
   try {
     const cachedVendorAbs = (0, import_path5.join)(vendorBaseDir, resolveVendorDir());
     if (import_fs5.default.existsSync(cachedVendorAbs)) {
-      const vendorFiles = await (0, import_build_utils6.glob)("**", cachedVendorAbs, resolveVendorDir());
+      const vendorFiles = await (0, import_build_utils7.glob)("**", cachedVendorAbs, resolveVendorDir());
       for (const [p, f] of Object.entries(vendorFiles)) {
         files[p] = f;
       }
@@ -4068,12 +4233,12 @@ var build = async ({
     throw err;
   }
   const handlerPyFilename = "vc__handler__python";
-  files[`${handlerPyFilename}.py`] = new import_build_utils6.FileBlob({ data: handlerPyContents });
+  files[`${handlerPyFilename}.py`] = new import_build_utils7.FileBlob({ data: handlerPyContents });
   if (config.framework === "fasthtml") {
     const { SESSKEY = "" } = process.env;
-    files[".sesskey"] = new import_build_utils6.FileBlob({ data: `"${SESSKEY}"` });
+    files[".sesskey"] = new import_build_utils7.FileBlob({ data: `"${SESSKEY}"` });
   }
-  const output = new import_build_utils6.Lambda({
+  const output = new import_build_utils7.Lambda({
     files,
     handler: `${handlerPyFilename}.vc_handler`,
     runtime: pythonVersion.runtime,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/python",
-  "version": "6.0.3",
+  "version": "6.0.5",
   "main": "./dist/index.js",
   "license": "Apache-2.0",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/python",
@@ -21,7 +21,7 @@
     "@types/jest": "27.4.1",
     "@types/node": "14.18.33",
     "@types/which": "3.0.0",
-    "@vercel/build-utils": "13.0.0",
+    "@vercel/build-utils": "13.0.1",
     "cross-env": "7.0.3",
     "execa": "^1.0.0",
     "fs-extra": "11.1.1",