@vercel/python 6.16.1 → 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");
@@ -4264,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)
@@ -4295,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 {
@@ -4309,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);
@@ -4579,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;
@@ -4753,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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/python",
-  "version": "6.16.1",
+  "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/python-runtime": "0.5.1",
-    "@vercel/build-utils": "13.5.0",
-    "@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)",