@vercel/python 6.16.0 → 6.17.0

package/dist/index.js

@@ -2871,8 +2871,8 @@ var import_fs6 = __toESM(require("fs"));
 var import_util2 = require("util");
 var import_path8 = require("path");
 
-// src/runtime-version.ts
-var VERCEL_RUNTIME_VERSION = "0.5.1";
+// src/package-versions.ts
+var VERCEL_RUNTIME_VERSION = "0.5.2";
 
 // src/index.ts
 var import_build_utils9 = require("@vercel/build-utils");
@@ -3880,6 +3880,19 @@ var PythonDependencyExternalizer = class {
     this.projectName = options.projectName;
     this.noBuildCheckFailed = options.noBuildCheckFailed;
     this.pythonPath = options.pythonPath;
+    this.hasCustomCommand = options.hasCustomCommand;
+  }
+  shouldEnableRuntimeInstall() {
+    if (this.hasCustomCommand) {
+      return false;
+    }
+    const pythonOnHiveEnabled = process.env.VERCEL_PYTHON_ON_HIVE === "1" || process.env.VERCEL_PYTHON_ON_HIVE === "true";
+    if (pythonOnHiveEnabled) {
+      return false;
+    } else if (this.totalBundleSize > LAMBDA_SIZE_THRESHOLD_BYTES && this.uvLockPath !== null) {
+      return true;
+    }
+    return false;
   }
   /**
    * Analyze the bundle: mirror all vendor files, calculate total size,
@@ -3899,11 +3912,24 @@ var PythonDependencyExternalizer = class {
     this.analyzed = true;
     const totalBundleSizeMB = (this.totalBundleSize / (1024 * 1024)).toFixed(2);
     (0, import_build_utils5.debug)(`Total bundle size: ${totalBundleSizeMB} MB`);
-    const overLambdaLimit = shouldEnableRuntimeInstall({
-      totalBundleSize: this.totalBundleSize,
-      uvLockPath: this.uvLockPath
-    });
-    return { overLambdaLimit, allVendorFiles: this.allVendorFiles };
+    const runtimeInstallEnabled = this.shouldEnableRuntimeInstall();
+    const pythonOnHiveEnabled = process.env.VERCEL_PYTHON_ON_HIVE === "1" || process.env.VERCEL_PYTHON_ON_HIVE === "true";
+    if (this.totalBundleSize > LAMBDA_SIZE_THRESHOLD_BYTES && this.hasCustomCommand && !pythonOnHiveEnabled) {
+      const limitMB = (LAMBDA_SIZE_THRESHOLD_BYTES / (1024 * 1024)).toFixed(0);
+      throw new import_build_utils5.NowBuildError({
+        code: "LAMBDA_SIZE_EXCEEDED",
+        message: `Total bundle size (${totalBundleSizeMB} MB) exceeds the Lambda size limit (${limitMB} MB).
+
+Runtime dependency installation is not available for projects that use a custom build or install command, because custom commands may install dependencies that are not tracked in uv.lock.
+
+To resolve this, either:
+  1. Remove the custom build/install command and let Vercel manage dependencies automatically
+  2. Reduce your dependency footprint to fit within the ${limitMB} MB limit`,
+        link: "https://vercel.com/docs/functions/runtimes/python#controlling-what-gets-bundled",
+        action: "Learn More"
+      });
+    }
+    return { runtimeInstallEnabled, allVendorFiles: this.allVendorFiles };
   }
   /**
    * Generate the optimally-packed Lambda bundle.
@@ -3931,7 +3957,9 @@ var PythonDependencyExternalizer = class {
       const ephemeralLimitMB = (LAMBDA_EPHEMERAL_STORAGE_BYTES / (1024 * 1024)).toFixed(0);
       throw new import_build_utils5.NowBuildError({
         code: "LAMBDA_SIZE_EXCEEDED",
-        message: `Total dependency size (${totalBundleSizeMB} MB) exceeds Lambda ephemeral storage limit (${ephemeralLimitMB} MB). Even with runtime dependency installation, all packages must fit within the ${ephemeralLimitMB} MB ephemeral storage available to Lambda functions. Consider removing unused dependencies or splitting your application into smaller functions.`
+        message: `Total dependency size (${totalBundleSizeMB} MB) exceeds Lambda ephemeral storage limit (${ephemeralLimitMB} MB). Even with runtime dependency installation, all packages must fit within the ${ephemeralLimitMB} MB ephemeral storage available to Lambda functions. Consider removing unused dependencies or splitting your application into smaller functions.`,
+        link: "https://vercel.com/docs/functions/runtimes/python#controlling-what-gets-bundled",
+        action: "Learn More"
       });
     }
     if (this.noBuildCheckFailed) {
@@ -4097,23 +4125,13 @@ ${error.fileContent}`
       const limitMB = (LAMBDA_SIZE_THRESHOLD_BYTES / (1024 * 1024)).toFixed(0);
       throw new import_build_utils5.NowBuildError({
         code: "LAMBDA_SIZE_EXCEEDED",
-        message: `Bundle size (${finalSizeMB} MB) exceeds Lambda limit (${limitMB} MB) even after deferring public packages to runtime installation. This usually means your private packages or source code are too large. Consider reducing the size of private dependencies or splitting your application.`
+        message: `Bundle size (${finalSizeMB} MB) exceeds Lambda limit (${limitMB} MB) even after deferring public packages to runtime installation. This usually means your private packages or source code are too large. Consider reducing the size of private dependencies or splitting your application.`,
+        link: "https://vercel.com/docs/functions/runtimes/python#controlling-what-gets-bundled",
+        action: "Learn More"
       });
     }
   }
 };
-function shouldEnableRuntimeInstall({
-  totalBundleSize,
-  uvLockPath
-}) {
-  const pythonOnHiveEnabled = process.env.VERCEL_PYTHON_ON_HIVE === "1" || process.env.VERCEL_PYTHON_ON_HIVE === "true";
-  if (pythonOnHiveEnabled) {
-    return false;
-  } else if (totalBundleSize > LAMBDA_SIZE_THRESHOLD_BYTES && uvLockPath !== null) {
-    return true;
-  }
-  return false;
-}
 async function mirrorPackagesIntoVendor({
   venvPath,
   vendorDirName,
@@ -4246,11 +4264,16 @@ var PYTHON_ENTRYPOINT_FILENAMES = [
   "asgi"
 ];
 var PYTHON_ENTRYPOINT_DIRS = ["", "src", "app", "api"];
-var PYTHON_CANDIDATE_ENTRYPOINTS = PYTHON_ENTRYPOINT_FILENAMES.flatMap(
-  (filename) => PYTHON_ENTRYPOINT_DIRS.map(
-    (dir) => import_path6.posix.join(dir, `${filename}.py`)
-  )
+var PYTHON_CANDIDATE_ENTRYPOINTS = getCandidateEntrypointsInDirs(
+  PYTHON_ENTRYPOINT_DIRS
 );
+function getCandidateEntrypointsInDirs(dirs) {
+  return dirs.flatMap(
+    (dir) => PYTHON_ENTRYPOINT_FILENAMES.map(
+      (filename) => import_path6.posix.join(dir, `${filename}.py`)
+    )
+  );
+}
 async function getPyprojectEntrypoint(workPath) {
   const pyprojectData = await (0, import_build_utils7.readConfigFile)((0, import_path6.join)(workPath, "pyproject.toml"));
   if (!pyprojectData)
@@ -4277,6 +4300,18 @@ async function getPyprojectEntrypoint(workPath) {
     return null;
   }
 }
+async function findValidEntrypoint(fsFiles, candidates) {
+  for (const candidate of candidates) {
+    if (fsFiles[candidate]) {
+      const isValid = await (0, import_build_utils6.isPythonEntrypoint)(fsFiles[candidate]);
+      if (isValid) {
+        (0, import_build_utils6.debug)(`Detected Python entrypoint: ${candidate}`);
+        return candidate;
+      }
+    }
+  }
+  return null;
+}
 async function detectGenericPythonEntrypoint(workPath, configuredEntrypoint) {
   const entry = configuredEntrypoint.endsWith(".py") ? configuredEntrypoint : `${configuredEntrypoint}.py`;
   try {
@@ -4291,24 +4326,54 @@ async function detectGenericPythonEntrypoint(workPath, configuredEntrypoint) {
     const candidates = PYTHON_CANDIDATE_ENTRYPOINTS.filter(
       (c) => !!fsFiles[c]
     );
-    for (const candidate of candidates) {
-      const isValid = await (0, import_build_utils6.isPythonEntrypoint)(fsFiles[candidate]);
+    return findValidEntrypoint(fsFiles, candidates);
+  } catch {
+    (0, import_build_utils6.debug)("Failed to discover Python entrypoint");
+    return null;
+  }
+}
+async function detectDjangoPythonEntrypoint(workPath, configuredEntrypoint) {
+  const entry = configuredEntrypoint.endsWith(".py") ? configuredEntrypoint : `${configuredEntrypoint}.py`;
+  try {
+    const fsFiles = await (0, import_build_utils6.glob)("**", workPath);
+    if (fsFiles[entry]) {
+      const isValid = await (0, import_build_utils6.isPythonEntrypoint)(fsFiles[entry]);
       if (isValid) {
-        (0, import_build_utils6.debug)(`Detected Python entrypoint: ${candidate}`);
-        return candidate;
+        (0, import_build_utils6.debug)(`Using configured Python entrypoint: ${entry}`);
+        return entry;
       }
     }
-    return null;
+    const rootGlobs = await (0, import_build_utils6.glob)("*", {
+      cwd: workPath,
+      includeDirectories: true
+    });
+    const rootDirs = [
+      "",
+      ...Object.keys(rootGlobs).filter(
+        (name) => !name.startsWith(".") && rootGlobs[name].mode != null && (0, import_build_utils6.isDirectory)(rootGlobs[name].mode)
+      )
+    ];
+    for (const rootDir of rootDirs) {
+      const currPath = (0, import_path6.join)(workPath, rootDir);
+      const wsgiEntry = await (0, import_build_utils6.getDjangoEntrypoint)(currPath);
+      if (wsgiEntry) {
+        const fullWsgiEntry = import_path6.posix.join(rootDir, wsgiEntry);
+        if (fsFiles[fullWsgiEntry]) {
+          (0, import_build_utils6.debug)(`Using Django WSGI entrypoint: ${fullWsgiEntry}`);
+          return fullWsgiEntry;
+        }
+      }
+    }
+    const baseCandidates = getCandidateEntrypointsInDirs(rootDirs);
+    const candidates = baseCandidates.filter((c) => !!fsFiles[c]);
+    return findValidEntrypoint(fsFiles, candidates);
   } catch {
-    (0, import_build_utils6.debug)("Failed to discover Python entrypoint");
+    (0, import_build_utils6.debug)("Failed to discover Django Python entrypoint");
     return null;
   }
 }
-async function detectPythonEntrypoint(_framework, workPath, configuredEntrypoint) {
-  const entrypoint = await detectGenericPythonEntrypoint(
-    workPath,
-    configuredEntrypoint
-  );
+async function detectPythonEntrypoint(framework, workPath, configuredEntrypoint) {
+  const entrypoint = framework === "django" ? await detectDjangoPythonEntrypoint(workPath, configuredEntrypoint) : await detectGenericPythonEntrypoint(workPath, configuredEntrypoint);
   if (entrypoint)
     return entrypoint;
   return await getPyprojectEntrypoint(workPath);
@@ -4561,17 +4626,25 @@ function installGlobalCleanupHandlers() {
     killAll();
   });
 }
-function createDevShim(workPath, modulePath) {
+function createDevShim(workPath, entry, modulePath) {
   try {
     const vercelPythonDir = (0, import_path7.join)(workPath, ".vercel", "python");
     (0, import_fs5.mkdirSync)(vercelPythonDir, { recursive: true });
+    let qualifiedModule = modulePath;
+    let extraPythonPath;
+    if ((0, import_fs5.existsSync)((0, import_path7.join)(workPath, "__init__.py"))) {
+      const pkgName = (0, import_path7.basename)(workPath);
+      qualifiedModule = `${pkgName}.${modulePath}`;
+      extraPythonPath = (0, import_path7.dirname)(workPath);
+    }
+    const entryAbs = (0, import_path7.join)(workPath, entry);
     const shimPath = (0, import_path7.join)(vercelPythonDir, `${DEV_SHIM_MODULE}.py`);
     const templatePath = (0, import_path7.join)(__dirname, "..", `${DEV_SHIM_MODULE}.py`);
     const template = (0, import_fs5.readFileSync)(templatePath, "utf8");
-    const shimSource = template.replace(/__VC_DEV_MODULE_PATH__/g, modulePath);
+    const shimSource = template.replace(/__VC_DEV_MODULE_NAME__/g, qualifiedModule).replace(/__VC_DEV_ENTRY_ABS__/g, entryAbs);
     (0, import_fs5.writeFileSync)(shimPath, shimSource, "utf8");
     (0, import_build_utils8.debug)(`Prepared Python dev shim at ${shimPath}`);
-    return DEV_SHIM_MODULE;
+    return { module: DEV_SHIM_MODULE, extraPythonPath };
   } catch (err) {
     (0, import_build_utils8.debug)(`Failed to prepare dev shim: ${err?.message || err}`);
     return null;
@@ -4735,22 +4808,33 @@ If you are using a virtual environment, activate it before running "vercel dev",
     }
     const port = typeof meta.port === "number" ? meta.port : await (0, import_get_port.default)();
     env.PORT = `${port}`;
-    const devShimModule = createDevShim(workPath, modulePath);
-    if (devShimModule) {
+    const devShim = createDevShim(workPath, entry, modulePath);
+    if (devShim) {
       const vercelPythonDir = (0, import_path7.join)(workPath, ".vercel", "python");
+      const pathParts = [vercelPythonDir];
+      if (devShim.extraPythonPath) {
+        pathParts.push(devShim.extraPythonPath);
+      }
       const existingPythonPath = env.PYTHONPATH || "";
-      env.PYTHONPATH = existingPythonPath ? `${vercelPythonDir}:${existingPythonPath}` : vercelPythonDir;
+      if (existingPythonPath) {
+        pathParts.push(existingPythonPath);
+      }
+      env.PYTHONPATH = pathParts.join(import_path7.delimiter);
     }
-    const moduleToRun = devShimModule || modulePath;
+    const moduleToRun = devShim?.module || modulePath;
     const pythonArgs = ["-u", "-m", moduleToRun];
     const argv = [...spawnArgsPrefix, ...pythonArgs];
     (0, import_build_utils8.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: ["inherit", "pipe", "pipe"]
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: true
     });
     childProcess = child;
     stdoutLogListener = createLogListener(onStdout, process.stdout);
@@ -4825,6 +4909,7 @@ var build = async ({
   const framework = config?.framework;
   let spawnEnv;
   let projectInstallCommand;
+  let hasCustomCommand = false;
   (0, import_build_utils9.debug)(`workPath: ${workPath}`);
   workPath = await downloadFilesInWorkPath({
     workPath,
@@ -4873,12 +4958,16 @@ var build = async ({
         env: spawnEnv,
         cwd: workPath
       });
+      hasCustomCommand = true;
     } else {
-      await runPyprojectScript(
+      const ranBuildScript = await runPyprojectScript(
         workPath,
         ["vercel-build", "now-build", "build"],
         spawnEnv
       );
+      if (ranBuildScript) {
+        hasCustomCommand = true;
+      }
     }
   }
   let fsFiles = await (0, import_build_utils9.glob)("**", workPath);
@@ -5011,6 +5100,7 @@ ${pipfileLockContent}`
       cwd: workPath
     });
     assumeDepsInstalled = true;
+    hasCustomCommand = true;
   } else {
     assumeDepsInstalled = await runPyprojectScript(
       workPath,
@@ -5019,6 +5109,9 @@ ${pipfileLockContent}`
       /* useUserVirtualEnv */
       false
     );
+    if (assumeDepsInstalled) {
+      hasCustomCommand = true;
+    }
   }
   let uv;
   try {
@@ -5159,10 +5252,11 @@ from vercel_runtime.vc_init import vc_handler
     uvProjectDir,
     projectName,
     noBuildCheckFailed,
-    pythonPath: pythonVersion.pythonPath
+    pythonPath: pythonVersion.pythonPath,
+    hasCustomCommand
   });
-  const { overLambdaLimit, allVendorFiles } = await depExternalizer.analyze(files);
-  if (overLambdaLimit) {
+  const { runtimeInstallEnabled, allVendorFiles } = await depExternalizer.analyze(files);
+  if (runtimeInstallEnabled) {
     await depExternalizer.generateBundle(files);
   } else {
     for (const [p, f] of Object.entries(allVendorFiles)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/python",
-  "version": "6.16.0",
+  "version": "6.17.0",
   "main": "./dist/index.js",
   "license": "Apache-2.0",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/python",
@@ -15,7 +15,7 @@
     "directory": "packages/python"
   },
   "dependencies": {
-    "@vercel/python-analysis": "0.7.0"
+    "@vercel/python-analysis": "0.8.0"
   },
   "devDependencies": {
     "@renovatebot/pep440": "4.2.1",
@@ -35,9 +35,9 @@
     "which": "3.0.0",
     "get-port": "5.1.1",
     "is-port-reachable": "3.1.0",
-    "@vercel/build-utils": "13.5.0",
-    "@vercel/python-runtime": "0.5.1",
-    "@vercel/error-utils": "2.0.3"
+    "@vercel/build-utils": "13.6.0",
+    "@vercel/error-utils": "2.0.3",
+    "@vercel/python-runtime": "0.5.2"
   },
   "scripts": {
     "build": "node ../../utils/build-builder.mjs",

package/vc_init_dev.py

@@ -5,7 +5,7 @@ import sys
 import os
 import inspect
 from os import path as _p
-from importlib import import_module
+from importlib import util as _importlib_util
 import mimetypes
 
 
@@ -72,8 +72,20 @@ def _strip_service_route_prefix(path_value):
 
 
 # ASGI/WSGI app detection
-USER_MODULE = "__VC_DEV_MODULE_PATH__"
-_mod = import_module(USER_MODULE)
+_MODULE_NAME = "__VC_DEV_MODULE_NAME__"
+_ENTRY_ABS = "__VC_DEV_ENTRY_ABS__"
+
+# Import user module by file path, matching vc_init.py's approach.
+# https://docs.python.org/3/library/importlib.html#importing-a-source-file-directly
+_spec = _importlib_util.spec_from_file_location(_MODULE_NAME, _ENTRY_ABS)
+if _spec is None or _spec.loader is None:
+    raise RuntimeError(
+        f"Could not load module spec for '{_MODULE_NAME}' at {_ENTRY_ABS}"
+    )
+_mod = _importlib_util.module_from_spec(_spec)
+sys.modules[_MODULE_NAME] = _mod
+_spec.loader.exec_module(_mod)
+
 _user_app_name = (
     "app"
     if hasattr(_mod, "app")
@@ -83,7 +95,7 @@ _user_app_name = (
 )
 if _user_app_name is None:
     raise RuntimeError(
-        f"Missing 'app' or 'application' in module '{USER_MODULE}'. "
+        f"Missing 'app' or 'application' in module '{_MODULE_NAME}'. "
         f"Define `app = ...` or `application = ...` in your entrypoint."
     )
 
@@ -137,7 +149,7 @@ def _detect_app_type(app_obj):
 
     print(
         _color(
-            f"Could not determine the application interface for '{USER_MODULE}:{_user_app_name}'\n"
+            f"Could not determine the application interface for '{_MODULE_NAME}:{_user_app_name}'\n"
             f"Expected either:\n"
             f"  - An ASGI app: async callable(scope, receive, send)\n"
             f"  - A WSGI app: callable(environ, start_response)",