@vercel/python 6.19.0 → 6.20.0

package/dist/index.js

@@ -2872,7 +2872,7 @@ var import_util2 = require("util");
 var import_path10 = require("path");
 
 // src/package-versions.ts
-var VERCEL_RUNTIME_VERSION = "0.5.3";
+var VERCEL_RUNTIME_VERSION = "0.5.4";
 
 // src/index.ts
 var import_build_utils12 = require("@vercel/build-utils");
@@ -2957,7 +2957,7 @@ var UvRunner = class {
     );
   }
   async sync(options) {
-    const { venvPath, projectDir, locked, frozen, noBuild } = options;
+    const { venvPath, projectDir, locked, frozen, noBuild, noInstallProject } = options;
     const args = ["sync", "--active", "--no-dev", "--link-mode", "copy"];
     if (frozen) {
       args.push("--frozen");
@@ -2967,6 +2967,9 @@ var UvRunner = class {
     if (noBuild) {
       args.push("--no-build");
     }
+    if (noInstallProject) {
+      args.push("--no-install-project");
+    }
     args.push("--no-editable");
     await this.runUvCmd(args, projectDir, venvPath);
   }
@@ -3930,7 +3933,11 @@ To resolve this, either:
         action: "Learn More"
       });
     }
-    return { runtimeInstallEnabled, allVendorFiles: this.allVendorFiles };
+    return {
+      runtimeInstallEnabled,
+      allVendorFiles: this.allVendorFiles,
+      totalBundleSize: this.totalBundleSize
+    };
   }
   /**
    * Generate the optimally-packed Lambda bundle.
@@ -4884,6 +4891,16 @@ If you are using a virtual environment, activate it before running "vercel dev",
 var import_build_utils11 = require("@vercel/build-utils");
 var import_python_analysis5 = require("@vercel/python-analysis");
 
+// src/quirks/matplotlib.ts
+var matplotlibQuirk = {
+  dependency: "matplotlib",
+  async run() {
+    return {
+      env: { MPLCONFIGDIR: "/tmp" }
+    };
+  }
+};
+
 // src/quirks/litellm.ts
 var import_fs6 = __toESM(require("fs"));
 var import_path8 = require("path");
@@ -5232,7 +5249,7 @@ echo "OpenSSL ${RUNTIME_OPENSSL_VERSION}.0 1 Jan 2024 (Library: OpenSSL ${RUNTIM
 };
 
 // src/quirks/index.ts
-var quirks = [litellmQuirk, prismaQuirk];
+var quirks = [litellmQuirk, prismaQuirk, matplotlibQuirk];
 function toposortQuirks(activated) {
   const nameToQuirk = /* @__PURE__ */ new Map();
   for (const q of activated) {
@@ -5360,8 +5377,10 @@ var build = async ({
   files: originalFiles,
   entrypoint,
   meta = {},
-  config
+  config,
+  span: parentSpan
 }) => {
+  const builderSpan = parentSpan ?? new import_build_utils12.Span({ name: "vc.builder" });
   const framework = config?.framework;
   let spawnEnv;
   let projectInstallCommand;
@@ -5423,67 +5442,74 @@ var build = async ({
     workPath,
     fsFiles
   });
-  let declaredPythonVersion;
-  if (pythonVersionFileDir) {
-    try {
-      const content = await readFile2(
-        (0, import_path10.join)(pythonVersionFileDir, ".python-version"),
-        "utf8"
-      );
-      const version2 = parsePythonVersionFile(content);
-      if (version2) {
-        declaredPythonVersion = { version: version2, source: ".python-version" };
-        (0, import_build_utils12.debug)(`Found Python version ${version2} in .python-version`);
+  const { pythonVersion, declaredPythonVersion } = await builderSpan.child("vc.builder.python.version").trace(async (versionSpan) => {
+    let declared;
+    if (pythonVersionFileDir) {
+      try {
+        const content = await readFile2(
+          (0, import_path10.join)(pythonVersionFileDir, ".python-version"),
+          "utf8"
+        );
+        const version2 = parsePythonVersionFile(content);
+        if (version2) {
+          declared = { version: version2, source: ".python-version" };
+          (0, import_build_utils12.debug)(`Found Python version ${version2} in .python-version`);
+        }
+      } catch (err) {
+        (0, import_build_utils12.debug)("Failed to read .python-version file", err);
       }
-    } catch (err) {
-      (0, import_build_utils12.debug)("Failed to read .python-version file", err);
-    }
-  }
-  if (!declaredPythonVersion && pyprojectDir) {
-    let requiresPython;
-    try {
-      const pyproject = await (0, import_build_utils13.readConfigFile)((0, import_path10.join)(pyprojectDir, "pyproject.toml"));
-      requiresPython = pyproject?.project?.["requires-python"];
-    } catch (err) {
-      (0, import_build_utils12.debug)("Failed to parse pyproject.toml", err);
-    }
-    if (typeof requiresPython === "string" && requiresPython.trim()) {
-      declaredPythonVersion = {
-        version: requiresPython.trim(),
-        source: "pyproject.toml"
-      };
-      (0, import_build_utils12.debug)(`Found requires-python "${requiresPython}" in pyproject.toml`);
     }
-  }
-  if (!declaredPythonVersion && pipfileLockDir) {
-    let lock = {};
-    const pipfileLockPath = (0, import_path10.join)(pipfileLockDir, "Pipfile.lock");
-    try {
-      const pipfileLockContent = await readFile2(pipfileLockPath, "utf8");
+    if (!declared && pyprojectDir) {
+      let requiresPython;
       try {
-        lock = JSON.parse(pipfileLockContent);
+        const pyproject = await (0, import_build_utils13.readConfigFile)((0, import_path10.join)(pyprojectDir, "pyproject.toml"));
+        requiresPython = pyproject?.project?.["requires-python"];
       } catch (err) {
-        console.log(
-          `Failed to parse "Pipfile.lock". File content:
-${pipfileLockContent}`
-        );
-        throw err;
+        (0, import_build_utils12.debug)("Failed to parse pyproject.toml", err);
+      }
+      if (typeof requiresPython === "string" && requiresPython.trim()) {
+        declared = {
+          version: requiresPython.trim(),
+          source: "pyproject.toml"
+        };
+        (0, import_build_utils12.debug)(`Found requires-python "${requiresPython}" in pyproject.toml`);
       }
-    } catch (err) {
-      throw new import_build_utils12.NowBuildError({
-        code: "INVALID_PIPFILE_LOCK",
-        message: "Unable to parse Pipfile.lock"
-      });
     }
-    const pyFromLock = lock?._meta?.requires?.python_version;
-    if (pyFromLock) {
-      declaredPythonVersion = { version: pyFromLock, source: "Pipfile.lock" };
-      (0, import_build_utils12.debug)(`Found Python version ${pyFromLock} in Pipfile.lock`);
+    if (!declared && pipfileLockDir) {
+      let lock = {};
+      const pipfileLockPath = (0, import_path10.join)(pipfileLockDir, "Pipfile.lock");
+      try {
+        const pipfileLockContent = await readFile2(pipfileLockPath, "utf8");
+        try {
+          lock = JSON.parse(pipfileLockContent);
+        } catch (err) {
+          console.log(
+            `Failed to parse "Pipfile.lock". File content:
+${pipfileLockContent}`
+          );
+          throw err;
+        }
+      } catch (err) {
+        throw new import_build_utils12.NowBuildError({
+          code: "INVALID_PIPFILE_LOCK",
+          message: "Unable to parse Pipfile.lock"
+        });
+      }
+      const pyFromLock = lock?._meta?.requires?.python_version;
+      if (pyFromLock) {
+        declared = { version: pyFromLock, source: "Pipfile.lock" };
+        (0, import_build_utils12.debug)(`Found Python version ${pyFromLock} in Pipfile.lock`);
+      }
     }
-  }
-  const pythonVersion = getSupportedPythonVersion({
-    isDev: meta.isDev,
-    declaredPythonVersion
+    const resolved = getSupportedPythonVersion({
+      isDev: meta.isDev,
+      declaredPythonVersion: declared
+    });
+    versionSpan.setAttributes({
+      "python.version": resolved.version,
+      "python.versionSource": declared?.source
+    });
+    return { pythonVersion: resolved, declaredPythonVersion: declared };
   });
   const selectedVersionTuple = parseVersionTuple(pythonVersion.version);
   const defaultVersionTuple = parseVersionTuple(DEFAULT_PYTHON_VERSION);
@@ -5497,9 +5523,11 @@ ${pipfileLockContent}`
   }
   fsFiles = await (0, import_build_utils12.glob)("**", workPath);
   const venvPath = (0, import_path10.join)(workPath, ".vercel", "python", ".venv");
-  await ensureVenv({
-    pythonPath: pythonVersion.pythonPath,
-    venvPath
+  await builderSpan.child("vc.builder.python.venv").trace(async () => {
+    await ensureVenv({
+      pythonPath: pythonVersion.pythonPath,
+      venvPath
+    });
   });
   if ((0, import_build_utils12.isPythonFramework)(framework)) {
     const {
@@ -5530,26 +5558,6 @@ ${pipfileLockContent}`
   const pythonEnv = createVenvEnv(venvPath, baseEnv);
   pythonEnv.VERCEL_PYTHON_VENV_PATH = venvPath;
   let assumeDepsInstalled = false;
-  if (projectInstallCommand) {
-    console.log(`Running "install" command: \`${projectInstallCommand}\`...`);
-    await (0, import_build_utils12.execCommand)(projectInstallCommand, {
-      env: pythonEnv,
-      cwd: workPath
-    });
-    assumeDepsInstalled = true;
-    hasCustomCommand = true;
-  } else {
-    assumeDepsInstalled = await runPyprojectScript(
-      workPath,
-      ["vercel-install", "now-install", "install"],
-      pythonEnv,
-      /* useUserVirtualEnv */
-      false
-    );
-    if (assumeDepsInstalled) {
-      hasCustomCommand = true;
-    }
-  }
   let uv;
   try {
     const uvPath = await getUvBinaryOrInstall(pythonVersion.pythonPath);
@@ -5565,62 +5573,93 @@ ${pipfileLockContent}`
   let uvProjectDir = null;
   let projectName;
   let noBuildCheckFailed = false;
-  if (!assumeDepsInstalled) {
-    const { projectDir, lockPath, lockFileProvidedByUser } = await ensureUvProject({
-      workPath,
-      entryDirectory,
-      repoRootPath,
-      pythonVersion: pythonVersion.version,
-      uv,
-      generateLockFile: true,
-      requireBinaryWheels: false
-    });
-    uvLockPath = lockPath;
-    uvProjectDir = projectDir;
-    const installInfo = await detectInstallSource({
-      workPath,
-      entryDirectory,
-      repoRootPath
-    });
-    projectName = installInfo.pythonPackage?.manifest?.data?.project?.name;
-    if (lockFileProvidedByUser) {
-      try {
-        await uv.sync({
-          venvPath,
-          projectDir,
-          frozen: true,
-          noBuild: true
-        });
-      } catch (err) {
-        noBuildCheckFailed = true;
-        (0, import_build_utils12.debug)(
-          `--no-build check failed: ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
-    }
-    await uv.sync({
-      venvPath,
-      projectDir,
-      frozen: lockFileProvidedByUser,
-      locked: !lockFileProvidedByUser
-    });
-  }
-  if ((0, import_build_utils12.isPythonFramework)(framework)) {
-    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_utils12.execCommand)(projectBuildCommand, {
+  await builderSpan.child(import_build_utils12.BUILDER_INSTALLER_STEP, {
+    installCommand: projectInstallCommand || void 0
+  }).trace(async () => {
+    if (projectInstallCommand) {
+      console.log(
+        `Running "install" command: \`${projectInstallCommand}\`...`
+      );
+      await (0, import_build_utils12.execCommand)(projectInstallCommand, {
         env: pythonEnv,
         cwd: workPath
       });
+      assumeDepsInstalled = true;
+      hasCustomCommand = true;
     } else {
-      await runPyprojectScript(
+      assumeDepsInstalled = await runPyprojectScript(
         workPath,
-        ["vercel-build", "now-build", "build"],
-        pythonEnv
+        ["vercel-install", "now-install", "install"],
+        pythonEnv,
+        /* useUserVirtualEnv */
+        false
       );
+      if (assumeDepsInstalled) {
+        hasCustomCommand = true;
+      }
+    }
+    if (!assumeDepsInstalled) {
+      const { projectDir, lockPath, lockFileProvidedByUser } = await ensureUvProject({
+        workPath,
+        entryDirectory,
+        repoRootPath,
+        pythonVersion: pythonVersion.version,
+        uv,
+        generateLockFile: true,
+        requireBinaryWheels: false
+      });
+      uvLockPath = lockPath;
+      uvProjectDir = projectDir;
+      const installInfo = await detectInstallSource({
+        workPath,
+        entryDirectory,
+        repoRootPath
+      });
+      projectName = installInfo.pythonPackage?.manifest?.data?.project?.name;
+      if (lockFileProvidedByUser) {
+        try {
+          await uv.sync({
+            venvPath,
+            projectDir,
+            frozen: true,
+            noBuild: true,
+            noInstallProject: true
+          });
+        } catch (err) {
+          noBuildCheckFailed = true;
+          (0, import_build_utils12.debug)(
+            `--no-build check failed: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
+      await uv.sync({
+        venvPath,
+        projectDir,
+        frozen: lockFileProvidedByUser,
+        locked: !lockFileProvidedByUser
+      });
     }
+  });
+  if ((0, import_build_utils12.isPythonFramework)(framework)) {
+    const projectBuildCommand = config?.projectSettings?.buildCommand ?? // fallback if provided directly on config (some callers set this)
+    config?.buildCommand;
+    await builderSpan.child(import_build_utils12.BUILDER_COMPILE_STEP, {
+      buildCommand: projectBuildCommand || void 0
+    }).trace(async () => {
+      if (projectBuildCommand) {
+        console.log(`Running "${projectBuildCommand}"`);
+        await (0, import_build_utils12.execCommand)(projectBuildCommand, {
+          env: pythonEnv,
+          cwd: workPath
+        });
+      } else {
+        await runPyprojectScript(
+          workPath,
+          ["vercel-build", "now-build", "build"],
+          pythonEnv
+        );
+      }
+    });
   }
   const runtimeDep = baseEnv.VERCEL_RUNTIME_PYTHON || `vercel-runtime==${VERCEL_RUNTIME_VERSION}`;
   (0, import_build_utils12.debug)(`Installing ${runtimeDep}`);
@@ -5715,14 +5754,22 @@ from vercel_runtime.vc_init import vc_handler
     hasCustomCommand,
     alwaysBundlePackages: quirksResult.alwaysBundlePackages
   });
-  const { runtimeInstallEnabled, allVendorFiles } = await depExternalizer.analyze(files);
-  if (runtimeInstallEnabled) {
-    await depExternalizer.generateBundle(files);
-  } else {
-    for (const [p, f] of Object.entries(allVendorFiles)) {
-      files[p] = f;
+  await builderSpan.child("vc.builder.python.bundle").trace(async (bundleSpan) => {
+    const depAnalysis = await depExternalizer.analyze(files);
+    bundleSpan.setAttributes({
+      "python.bundle.totalSizeBytes": String(depAnalysis.totalBundleSize),
+      "python.bundle.runtimeInstallEnabled": String(
+        depAnalysis.runtimeInstallEnabled
+      )
+    });
+    if (depAnalysis.runtimeInstallEnabled) {
+      await depExternalizer.generateBundle(files);
+    } else {
+      for (const [p, f] of Object.entries(depAnalysis.allVendorFiles)) {
+        files[p] = f;
+      }
     }
-  }
+  });
   const handlerPyFilename = "vc__handler__python";
   files[`${handlerPyFilename}.py`] = new import_build_utils12.FileBlob({ data: runtimeTrampoline });
   if (config.framework === "fasthtml") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/python",
-  "version": "6.19.0",
+  "version": "6.20.0",
   "main": "./dist/index.js",
   "license": "Apache-2.0",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/python",
@@ -35,9 +35,9 @@
     "which": "3.0.0",
     "get-port": "5.1.1",
     "is-port-reachable": "3.1.0",
-    "@vercel/build-utils": "13.6.1",
+    "@vercel/build-utils": "13.6.2",
     "@vercel/error-utils": "2.0.3",
-    "@vercel/python-runtime": "0.5.3"
+    "@vercel/python-runtime": "0.5.4"
   },
   "scripts": {
     "build": "node ../../utils/build-builder.mjs",