@vercel/python 6.12.0-canary.20260211174907.cdd2da6 → 6.12.0

package/dist/index.js

@@ -2753,7 +2753,7 @@ var import_util = require("util");
 var import_path7 = require("path");
 
 // src/runtime-version.ts
-var VERCEL_RUNTIME_VERSION = "0.3.0";
+var VERCEL_RUNTIME_VERSION = "0.4.0";
 
 // src/index.ts
 var import_build_utils8 = require("@vercel/build-utils");
@@ -3070,7 +3070,8 @@ function createVenvEnv(venvPath, baseEnv = process.env) {
 async function ensureVenv({
   pythonPath,
   venvPath,
-  uvPath
+  uvPath,
+  quiet
 }) {
   const marker = (0, import_path3.join)(venvPath, "pyvenv.cfg");
   try {
@@ -3079,7 +3080,9 @@ async function ensureVenv({
   } catch {
   }
   await import_fs2.default.promises.mkdir(venvPath, { recursive: true });
-  console.log(`Creating virtual environment at "${venvPath}"...`);
+  if (!quiet) {
+    console.log(`Creating virtual environment at "${venvPath}"...`);
+  }
   if (uvPath) {
     await (0, import_execa2.default)(uvPath, ["venv", venvPath]);
   } else {
@@ -3490,6 +3493,12 @@ async function detectInstallSource({
     });
   } catch (error) {
     if (error instanceof import_python_analysis.PythonAnalysisError) {
+      if (error.fileContent && (error.code.endsWith("_PARSE_ERROR") || error.code.endsWith("_VALIDATION_ERROR"))) {
+        console.log(
+          `Failed to parse "${error.path}". File content:
+${error.fileContent}`
+        );
+      }
       throw toBuildError(error);
     }
     throw error;
@@ -3805,6 +3814,7 @@ async function detectPythonEntrypoint(_framework, workPath, configuredEntrypoint
 }
 
 // src/start-dev-server.ts
+var import_python_analysis2 = require("@vercel/python-analysis");
 function silenceNodeWarnings() {
   const original = process.emitWarning.bind(
     process
@@ -3848,6 +3858,146 @@ function createLogListener(callback, stream) {
     }
   };
 }
+async function syncDependencies({
+  workPath,
+  uvPath,
+  pythonBin,
+  env,
+  onStdout,
+  onStderr
+}) {
+  const installInfo = await detectInstallSource({
+    workPath,
+    entryDirectory: "."
+  });
+  let { manifestType, manifestPath } = installInfo;
+  const manifest = installInfo.pythonPackage?.manifest;
+  if (!manifestType || !manifestPath) {
+    (0, import_build_utils7.debug)("No Python project manifest found, skipping dependency sync");
+    return;
+  }
+  if (manifest?.origin && manifestType === "pyproject.toml") {
+    const syncDir = (0, import_path6.join)(workPath, ".vercel", "python", "sync");
+    (0, import_fs4.mkdirSync)(syncDir, { recursive: true });
+    const tempPyproject = (0, import_path6.join)(syncDir, "pyproject.toml");
+    const content = (0, import_python_analysis2.stringifyManifest)(manifest.data);
+    (0, import_fs4.writeFileSync)(tempPyproject, content, "utf8");
+    manifestPath = tempPyproject;
+    (0, import_build_utils7.debug)(
+      `Wrote converted ${manifest.origin.kind} manifest to ${tempPyproject}`
+    );
+  }
+  const writeOut = (msg) => {
+    if (onStdout) {
+      onStdout(Buffer.from(msg));
+    } else {
+      process.stdout.write(msg);
+    }
+  };
+  const writeErr = (msg) => {
+    if (onStderr) {
+      onStderr(Buffer.from(msg));
+    } else {
+      process.stderr.write(msg);
+    }
+  };
+  const captured = [];
+  try {
+    await runSync({
+      manifestType,
+      manifestPath,
+      uvPath,
+      pythonBin,
+      env,
+      onStdout: (data) => captured.push(["stdout", data]),
+      onStderr: (data) => captured.push(["stderr", data])
+    });
+  } catch (err) {
+    for (const [channel, chunk] of captured) {
+      (channel === "stdout" ? writeOut : writeErr)(chunk.toString());
+    }
+    throw new import_build_utils7.NowBuildError({
+      code: "PYTHON_DEPENDENCY_SYNC_FAILED",
+      message: `Failed to install Python dependencies from ${manifestType}: ${err instanceof Error ? err.message : String(err)}`
+    });
+  }
+}
+async function runSync({
+  manifestType,
+  manifestPath,
+  uvPath,
+  pythonBin,
+  env,
+  onStdout,
+  onStderr
+}) {
+  const projectDir = (0, import_path6.dirname)(manifestPath);
+  const pip = uvPath ? { cmd: uvPath, prefix: ["pip", "install"] } : { cmd: pythonBin, prefix: ["-m", "pip", "install"] };
+  let spawnCmd;
+  let spawnArgs;
+  switch (manifestType) {
+    case "uv.lock": {
+      if (!uvPath) {
+        throw new import_build_utils7.NowBuildError({
+          code: "PYTHON_DEPENDENCY_SYNC_FAILED",
+          message: "uv is required to install dependencies from uv.lock.",
+          link: "https://docs.astral.sh/uv/getting-started/installation/",
+          action: "Install uv"
+        });
+      }
+      spawnCmd = uvPath;
+      spawnArgs = ["sync"];
+      break;
+    }
+    case "pylock.toml": {
+      spawnCmd = pip.cmd;
+      spawnArgs = [...pip.prefix, "-r", manifestPath];
+      break;
+    }
+    case "pyproject.toml": {
+      spawnCmd = pip.cmd;
+      spawnArgs = [...pip.prefix, projectDir];
+      break;
+    }
+    default:
+      (0, import_build_utils7.debug)(`Unknown manifest type: ${manifestType}`);
+      return;
+  }
+  await new Promise((resolve, reject) => {
+    (0, import_build_utils7.debug)(`Running "${spawnCmd} ${spawnArgs.join(" ")}" in ${projectDir}...`);
+    const child = (0, import_child_process2.spawn)(spawnCmd, spawnArgs, {
+      cwd: projectDir,
+      env: getProtectedUvEnv(env),
+      stdio: ["inherit", "pipe", "pipe"]
+    });
+    child.stdout?.on("data", (data) => {
+      if (onStdout) {
+        onStdout(data);
+      } else {
+        process.stdout.write(data.toString());
+      }
+    });
+    child.stderr?.on("data", (data) => {
+      if (onStderr) {
+        onStderr(data);
+      } else {
+        process.stderr.write(data.toString());
+      }
+    });
+    child.on("error", reject);
+    child.on("exit", (code, signal) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(
+          new Error(
+            `Command "${spawnCmd} ${spawnArgs.join(" ")}" failed with code ${code}, signal ${signal}`
+          )
+        );
+      }
+    });
+  });
+}
 var PERSISTENT_SERVERS = /* @__PURE__ */ new Map();
 var PENDING_STARTS = /* @__PURE__ */ new Map();
 var restoreWarnings = null;
@@ -3928,7 +4078,7 @@ async function getMultiServicePythonRunner(workPath, env, systemPython, uvPath)
     return { command: pythonCmd, args: [] };
   }
   const venvPath = (0, import_path6.join)(workPath, ".venv");
-  await ensureVenv({ pythonPath: systemPython, venvPath, uvPath });
+  await ensureVenv({ pythonPath: systemPython, venvPath, uvPath, quiet: true });
   (0, import_build_utils7.debug)(`Created virtualenv at ${venvPath} for multi-service dev`);
   const pythonBin = getVenvPythonBin(venvPath);
   const binDir = getVenvBinDir(venvPath);
@@ -4058,6 +4208,25 @@ If you are using a virtual environment, activate it before running "vercel dev",
         }
       }
     }
+    if (meta.syncDependencies) {
+      const gray = "\x1B[90m";
+      const reset = "\x1B[0m";
+      const syncMessage = `${gray}Synchronizing dependencies...${reset}
+`;
+      if (onStdout) {
+        onStdout(Buffer.from(syncMessage));
+      } else {
+        console.log(syncMessage);
+      }
+      await syncDependencies({
+        workPath,
+        uvPath,
+        pythonBin: spawnCommand,
+        env,
+        onStdout,
+        onStderr
+      });
+    }
     await new Promise((resolve, reject) => {
       let resolved = false;
       if (framework !== "flask") {
@@ -4372,9 +4541,18 @@ var build = async ({
   }
   if (!declaredPythonVersion && pipfileLockDir) {
     let lock = {};
+    const pipfileLockPath = (0, import_path7.join)(pipfileLockDir, "Pipfile.lock");
     try {
-      const json = await readFile((0, import_path7.join)(pipfileLockDir, "Pipfile.lock"), "utf8");
-      lock = JSON.parse(json);
+      const pipfileLockContent = await readFile(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_utils8.NowBuildError({
         code: "INVALID_PIPFILE_LOCK",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/python",
-  "version": "6.12.0-canary.20260211174907.cdd2da6",
+  "version": "6.12.0",
   "main": "./dist/index.js",
   "license": "Apache-2.0",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/python",
@@ -16,7 +16,7 @@
     "directory": "packages/python"
   },
   "dependencies": {
-    "@vercel/python-analysis": "0.5.0-canary.20260211174907.cdd2da6"
+    "@vercel/python-analysis": "0.4.1"
   },
   "devDependencies": {
     "@renovatebot/pep440": "4.2.1",
@@ -34,8 +34,8 @@
     "smol-toml": "1.5.2",
     "vitest": "2.1.4",
     "which": "3.0.0",
-    "@vercel/build-utils": "13.4.0-canary.20260211174907.cdd2da6",
-    "@vercel/error-utils": "2.1.0-canary.20260211174907.cdd2da6"
+    "@vercel/build-utils": "13.4.0",
+    "@vercel/error-utils": "2.0.3"
   },
   "scripts": {
     "build": "node ../../utils/build-builder.mjs",