@vercel/python 24.0.1 → 25.1.0

package/dist/index.js

@@ -9017,12 +9017,18 @@ async function syncDependencies({
   pythonBin,
   env,
   onStdout,
-  onStderr
+  onStderr,
+  onlyGroup,
+  activeVenv
 }) {
   const pythonPackage = await discoverPackage({
     entrypointDir: workPath,
     rootDir: workPath
   });
+  if (onlyGroup && !(onlyGroup in (pythonPackage.manifest?.data?.["dependency-groups"] ?? {}))) {
+    (0, import_build_utils15.debug)(`No "${onlyGroup}" dependency group found, skipping dependency sync`);
+    return;
+  }
   const installInfo = detectInstallSource(pythonPackage, workPath);
   const { manifestType } = installInfo;
   let { manifestPath } = installInfo;
@@ -9064,6 +9070,8 @@ async function syncDependencies({
       uvPath,
       pythonBin,
       env,
+      onlyGroup,
+      activeVenv,
       onStdout: (data) => captured.push(["stdout", data]),
       onStderr: (data) => captured.push(["stderr", data])
     });
@@ -9083,6 +9091,8 @@ async function runSync({
   uvPath,
   pythonBin,
   env,
+  onlyGroup,
+  activeVenv,
   onStdout,
   onStderr
 }) {
@@ -9102,16 +9112,32 @@ async function runSync({
       }
       spawnCmd = uvPath;
       spawnArgs = ["sync"];
+      if (activeVenv) {
+        spawnArgs.push("--active");
+      }
+      if (onlyGroup) {
+        spawnArgs.push("--only-group", onlyGroup, "--no-install-project");
+      }
       break;
     }
     case "pylock.toml": {
       spawnCmd = pip.cmd;
-      spawnArgs = [...pip.prefix, "-r", manifestPath];
+      spawnArgs = [...pip.prefix];
+      if (onlyGroup) {
+        spawnArgs.push("--group", onlyGroup);
+      } else {
+        spawnArgs.push("-r", manifestPath);
+      }
       break;
     }
     case "pyproject.toml": {
       spawnCmd = pip.cmd;
-      spawnArgs = [...pip.prefix, projectDir];
+      spawnArgs = [...pip.prefix];
+      if (onlyGroup) {
+        spawnArgs.push("--group", onlyGroup);
+      } else {
+        spawnArgs.push(projectDir);
+      }
       break;
     }
     default:
@@ -9364,7 +9390,229 @@ async function getMultiServicePythonRunner(workPath, env, systemPython, uvPath)
   env.PATH = `${binDir}${import_path13.delimiter}${env.PATH || ""}`;
   return { command: pythonBin, args: [] };
 }
+async function getPersistentServer(serverKey, isStale) {
+  while (true) {
+    const existing = PERSISTENT_SERVERS.get(serverKey);
+    if (existing) {
+      if (isStale?.(existing)) {
+        killPersistentServer(serverKey);
+      } else {
+        return {
+          port: existing.port,
+          pid: existing.pid,
+          shutdown: async () => {
+          }
+        };
+      }
+    }
+    const pending = PENDING_STARTS.get(serverKey);
+    if (!pending)
+      return null;
+    await pending;
+  }
+}
+async function spawnPersistentServer({
+  serverKey,
+  workPath,
+  entry,
+  modulePath,
+  shimSubdir,
+  framework,
+  variableName,
+  extraPythonPath,
+  spawnCommand,
+  spawnArgsPrefix,
+  port: requestedPort,
+  env,
+  onStdout,
+  onStderr,
+  scheduleModule,
+  scheduleEnv
+}) {
+  const port = requestedPort ?? await (0, import_get_port.default)();
+  env.PORT = `${port}`;
+  if (entry) {
+    env.__VC_HANDLER_ENTRYPOINT_ABS = (0, import_path13.join)(workPath, entry);
+  }
+  const devShim = createDevShim(
+    workPath,
+    entry,
+    modulePath,
+    shimSubdir,
+    framework,
+    variableName
+  );
+  if (devShim) {
+    const shimDir = devShim.shimDir || (0, import_path13.join)(workPath, ".vercel", "python");
+    const runtimeDir = (0, import_path13.join)(workPath, ".vercel", "python");
+    const pathParts = shimDir !== runtimeDir ? [shimDir, runtimeDir] : [shimDir];
+    if (devShim.extraPythonPath) {
+      pathParts.push(devShim.extraPythonPath);
+    }
+    if (extraPythonPath) {
+      pathParts.push(extraPythonPath);
+    }
+    const existingPythonPath = env.PYTHONPATH || "";
+    if (existingPythonPath) {
+      pathParts.push(existingPythonPath);
+    }
+    env.PYTHONPATH = pathParts.join(import_path13.delimiter);
+  }
+  const moduleToRun = devShim?.module || modulePath;
+  const pythonArgs = ["-u", "-m", moduleToRun];
+  const argv = [...spawnArgsPrefix, ...pythonArgs];
+  (0, import_build_utils15.debug)(
+    `Starting Python dev server (${framework}): ${spawnCommand} ${argv.join(" ")} [PORT=${port}]`
+  );
+  if (process.stdout.columns) {
+    env.COLUMNS = `${process.stdout.columns}`;
+  }
+  const child = (0, import_child_process2.spawn)(spawnCommand, argv, {
+    cwd: workPath,
+    env,
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: true
+  });
+  const stdoutLogListener = createLogListener(onStdout, process.stdout);
+  const stderrLogListener = createLogListener(onStderr, process.stderr);
+  child.stdout?.on("data", stdoutLogListener);
+  child.stderr?.on("data", stderrLogListener);
+  const childExited = new Promise((_resolve, reject) => {
+    child.once("error", (err) => {
+      reject(err);
+    });
+    child.once("exit", (code, signal) => {
+      reject(
+        new Error(
+          `Python dev server exited before binding (code=${code}, signal=${signal})`
+        )
+      );
+    });
+  });
+  await Promise.race([
+    checkForPort(port, DEV_SERVER_STARTUP_TIMEOUT),
+    childExited
+  ]);
+  const pid = child.pid;
+  PERSISTENT_SERVERS.set(serverKey, {
+    port,
+    pid,
+    child,
+    stdoutLogListener,
+    stderrLogListener,
+    scheduleModule,
+    scheduleEnv
+  });
+  return { port, pid };
+}
+var PROXY_DEPENDENCY_GROUP = "vercel.proxy";
+var startProxyDevServer = async ({
+  entrypoint,
+  workPath,
+  meta = {},
+  config,
+  onStdout,
+  onStderr
+}) => {
+  const handlerFunction = config?.handlerFunction;
+  if (typeof handlerFunction !== "string" || !handlerFunction) {
+    throw new Error(
+      'Python proxy dev server requires "config.handlerFunction" to be set'
+    );
+  }
+  const serverKey = `${workPath}::proxy::${entrypoint}`;
+  const existing = await getPersistentServer(serverKey);
+  if (existing) {
+    return existing;
+  }
+  if (!restoreWarnings)
+    restoreWarnings = silenceNodeWarnings();
+  installGlobalCleanupHandlers();
+  const proxySource = (0, import_fs13.readFileSync)((0, import_path13.join)(workPath, entrypoint), "utf8");
+  if (!await (0, import_python_analysis8.containsTopLevelCallable)(proxySource, handlerFunction)) {
+    throw new import_build_utils15.NowBuildError({
+      code: "PYTHON_HANDLER_NOT_FOUND",
+      message: `Handler function "${handlerFunction}" not found in ${entrypoint}. Ensure it is defined at the module's top level.`
+    });
+  }
+  const env = { ...process.env, ...meta.env || {} };
+  let resolveChildReady;
+  let rejectChildReady;
+  const childReady = new Promise(
+    (resolve4, reject) => {
+      resolveChildReady = resolve4;
+      rejectChildReady = reject;
+    }
+  );
+  PENDING_STARTS.set(serverKey, childReady);
+  try {
+    const { pythonPath: systemPython } = getDefaultPythonVersion(meta);
+    const uvPath = await findUvBinary(systemPython);
+    if (uvPath) {
+      checkUvBinaryVersion(uvPath);
+    }
+    const venvPath = (0, import_path13.join)(
+      workPath,
+      ".vercel",
+      "python",
+      PROXY_DEPENDENCY_GROUP,
+      ".venv"
+    );
+    await ensureVenv({
+      pythonVersion: { pythonPath: systemPython },
+      venvPath,
+      uvPath,
+      quiet: true
+    });
+    const pythonCmd = getVenvPythonBin(venvPath);
+    env.VIRTUAL_ENV = venvPath;
+    env.PATH = `${getVenvBinDir(venvPath)}${import_path13.delimiter}${env.PATH || ""}`;
+    await syncDependencies({
+      workPath,
+      uvPath,
+      pythonBin: pythonCmd,
+      env,
+      onStdout,
+      onStderr,
+      onlyGroup: PROXY_DEPENDENCY_GROUP,
+      activeVenv: true
+    });
+    await installInjectedDevPackage(
+      {
+        name: "vercel-runtime",
+        pinnedVersion: VERCEL_RUNTIME_VERSION,
+        envOverride: env.VERCEL_RUNTIME_PYTHON
+      },
+      { workPath, uvPath, pythonBin: pythonCmd, env, onStdout, onStderr }
+    );
+    const { port, pid } = await spawnPersistentServer({
+      serverKey,
+      workPath,
+      entry: entrypoint,
+      modulePath: entrypointToModule(entrypoint),
+      shimSubdir: PROXY_DEPENDENCY_GROUP,
+      framework: "python",
+      variableName: handlerFunction,
+      spawnCommand: pythonCmd,
+      spawnArgsPrefix: [],
+      env,
+      onStdout,
+      onStderr
+    });
+    resolveChildReady({ port, pid });
+    return { port, pid, shutdown: async () => {
+    } };
+  } catch (err) {
+    rejectChildReady(err);
+    throw err;
+  } finally {
+    PENDING_STARTS.delete(serverKey);
+  }
+};
 var startDevServer = async (opts) => {
+  if (opts.config?.middleware === true) {
+    return startProxyDevServer(opts);
+  }
   const {
     entrypoint: rawEntrypoint,
     workPath,
@@ -9382,24 +9630,12 @@ var startDevServer = async (opts) => {
   const scheduleEnv = scheduleFunction ? { ...env } : void 0;
   const serviceName = service?.name ?? (typeof meta.serviceName === "string" ? meta.serviceName : void 0);
   const serverKey = scheduleFunction ? `${workPath}::schedule::${scheduleFunction.outputPath}` : serviceName ? `${workPath}::${framework}::${serviceName}` : `${workPath}::${framework}`;
-  while (true) {
-    const existing = PERSISTENT_SERVERS.get(serverKey);
-    if (existing) {
-      if (scheduleFunction && (existing.scheduleModule !== scheduleModule || !(0, import_util2.isDeepStrictEqual)(existing.scheduleEnv, scheduleEnv))) {
-        killPersistentServer(serverKey);
-      } else {
-        return {
-          port: existing.port,
-          pid: existing.pid,
-          shutdown: async () => {
-          }
-        };
-      }
-    }
-    const pending = PENDING_STARTS.get(serverKey);
-    if (!pending)
-      break;
-    await pending;
+  const existing = await getPersistentServer(
+    serverKey,
+    (info) => !!scheduleFunction && (info.scheduleModule !== scheduleModule || !(0, import_util2.isDeepStrictEqual)(info.scheduleEnv, scheduleEnv))
+  );
+  if (existing) {
+    return existing;
   }
   if (!framework && !scheduleFunction) {
     return null;
@@ -9461,9 +9697,6 @@ var startDevServer = async (opts) => {
   }
   const { entrypoint: entry, variableName } = resolved;
   const modulePath = scheduleHandlerPath ? generatedPythonPathToModule(scheduleHandlerPath) : entrypointToModule(entry);
-  let childProcess = null;
-  let stdoutLogListener = null;
-  let stderrLogListener = null;
   let resolveChildReady;
   let rejectChildReady;
   const childReady = new Promise(
@@ -9713,82 +9946,25 @@ If you are using a virtual environment, activate it before running "vercel dev",
     if (crons?.length) {
       env.__VC_CRON_ROUTES = JSON.stringify(buildCronRouteTable(crons));
     }
-    const port = typeof meta.port === "number" ? meta.port : await (0, import_get_port.default)();
-    env.PORT = `${port}`;
-    if (entry) {
-      env.__VC_HANDLER_ENTRYPOINT_ABS = (0, import_path13.join)(workPath, entry);
-    }
-    const devShim = createDevShim(
+    const { port, pid } = await spawnPersistentServer({
+      serverKey,
       workPath,
       entry,
       modulePath,
-      scheduleHandlerPath ? scheduleHandlerPath.replace(/\.py$/, "") : serviceName && import_path13.posix.join("services", serviceName),
-      framework ?? "python",
-      variableName ?? ""
-    );
-    if (devShim) {
-      const shimDir = devShim.shimDir || (0, import_path13.join)(workPath, ".vercel", "python");
-      const runtimeDir = (0, import_path13.join)(workPath, ".vercel", "python");
-      const pathParts = shimDir !== runtimeDir ? [shimDir, runtimeDir] : [shimDir];
-      if (devShim.extraPythonPath) {
-        pathParts.push(devShim.extraPythonPath);
-      }
-      if (hookResult?.extraPythonPath) {
-        pathParts.push(hookResult.extraPythonPath);
-      }
-      const existingPythonPath = env.PYTHONPATH || "";
-      if (existingPythonPath) {
-        pathParts.push(existingPythonPath);
-      }
-      env.PYTHONPATH = pathParts.join(import_path13.delimiter);
-    }
-    const moduleToRun = devShim?.module || modulePath;
-    const pythonArgs = ["-u", "-m", moduleToRun];
-    const argv = [...spawnArgsPrefix, ...pythonArgs];
-    (0, import_build_utils15.debug)(
-      `Starting Python dev server (${framework}): ${spawnCommand} ${argv.join(" ")} [PORT=${port}]`
-    );
-    if (process.stdout.columns) {
-      env.COLUMNS = `${process.stdout.columns}`;
-    }
-    const child = (0, import_child_process2.spawn)(spawnCommand, argv, {
-      cwd: workPath,
+      shimSubdir: scheduleHandlerPath ? scheduleHandlerPath.replace(/\.py$/, "") : serviceName && import_path13.posix.join("services", serviceName),
+      framework: framework ?? "python",
+      variableName: variableName ?? "",
+      extraPythonPath: hookResult?.extraPythonPath,
+      spawnCommand,
+      spawnArgsPrefix,
+      port: typeof meta.port === "number" ? meta.port : void 0,
       env,
-      stdio: ["ignore", "pipe", "pipe"],
-      detached: true
-    });
-    childProcess = child;
-    stdoutLogListener = createLogListener(onStdout, process.stdout);
-    stderrLogListener = createLogListener(onStderr, process.stderr);
-    child.stdout?.on("data", stdoutLogListener);
-    child.stderr?.on("data", stderrLogListener);
-    const childExited = new Promise((_resolve, reject) => {
-      child.once("error", (err) => {
-        reject(err);
-      });
-      child.once("exit", (code, signal) => {
-        reject(
-          new Error(
-            `Python dev server exited before binding (code=${code}, signal=${signal})`
-          )
-        );
-      });
-    });
-    await Promise.race([
-      checkForPort(port, DEV_SERVER_STARTUP_TIMEOUT),
-      childExited
-    ]);
-    const pid = child.pid;
-    resolveChildReady({ port, pid });
-    PERSISTENT_SERVERS.set(serverKey, {
-      port,
-      pid,
-      child: childProcess,
-      stdoutLogListener,
-      stderrLogListener,
+      onStdout,
+      onStderr,
       scheduleModule,
       scheduleEnv
     });
+    resolveChildReady({ port, pid });
     const shutdown = async () => {
     };
     return { port, pid, shutdown, crons, queueSubscriptions };
@@ -12051,7 +12227,9 @@ async function buildProxyMiddleware({
       // Install only the proxy's dependency group into the proxy venv;
       // the project itself is neither built nor installed.
       // If the group is absent the proxy has no extra deps — skip sync.
-      extraSyncParams: "vercel.proxy" in (pythonPackage?.manifest?.data?.["dependency-groups"] ?? {}) ? { onlyGroup: "vercel.proxy", noInstallProject: true } : void 0
+      // Group names are normalized on read, so `vercel.proxy` is keyed
+      // as `vercel-proxy`.
+      extraSyncParams: "vercel-proxy" in (pythonPackage?.manifest?.data?.["dependency-groups"] ?? {}) ? { onlyGroup: "vercel.proxy", noInstallProject: true } : void 0
     })
   );
   const pipPlatformArgs = target.uvPlatform ? ["--python-platform", target.uvPlatform] : [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/python",
-  "version": "24.0.1",
+  "version": "25.1.0",
   "main": "./dist/index.js",
   "license": "Apache-2.0",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/python",
@@ -14,10 +14,10 @@
     "directory": "packages/python"
   },
   "dependencies": {
-    "@vercel/python-analysis": "0.14.0"
+    "@vercel/python-analysis": "0.15.0"
   },
   "peerDependencies": {
-    "@vercel/build-utils": "14.20.1"
+    "@vercel/build-utils": "14.21.1"
   },
   "devDependencies": {
     "@renovatebot/pep440": "4.2.1",
@@ -38,7 +38,7 @@
     "vitest": "4.1.10",
     "which": "3.0.0",
     "@vercel/error-utils": "2.2.1",
-    "@vercel/build-utils": "14.20.1",
+    "@vercel/build-utils": "14.21.1",
     "@vercel/python-runtime": "0.23.2"
   },
   "scripts": {