@vercel/python 5.0.1 → 5.0.3

package/dist/index.js

@@ -2651,7 +2651,7 @@ ${stderr}${stdout}`;
 var require_lib = __commonJS({
   "../../node_modules/.pnpm/which@3.0.0/node_modules/which/lib/index.js"(exports, module2) {
     var isexe = require_isexe();
-    var { join: join2, delimiter, sep, posix } = require("path");
+    var { join: join3, delimiter, sep, posix } = require("path");
     var isWindows = process.platform === "win32";
     var rSlash = new RegExp(`[${posix.sep}${sep === posix.sep ? "" : sep}]`.replace(/(\\)/g, "\\$1"));
     var rRel = new RegExp(`^\\.${rSlash.source}`);
@@ -2680,7 +2680,7 @@ var require_lib = __commonJS({
     var getPathPart = (raw, cmd) => {
       const pathPart = /^".*"$/.test(raw) ? raw.slice(1, -1) : raw;
       const prefix = !pathPart && rRel.test(cmd) ? cmd.slice(0, 2) : "";
-      return prefix + join2(pathPart, cmd);
+      return prefix + join3(pathPart, cmd);
     };
     var which2 = async (cmd, opt = {}) => {
       const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
@@ -2749,11 +2749,12 @@ module.exports = __toCommonJS(src_exports);
 var import_fs = __toESM(require("fs"));
 var import_execa2 = __toESM(require_execa());
 var import_util = require("util");
-var import_path = require("path");
+var import_path2 = require("path");
 var import_build_utils3 = require("@vercel/build-utils");
 
 // src/install.ts
 var import_execa = __toESM(require_execa());
+var import_path = require("path");
 var import_build_utils = require("@vercel/build-utils");
 var makeDependencyCheckCode = (dependency) => `
 from importlib import util
@@ -2768,7 +2769,8 @@ async function isInstalled(pythonPath, dependency, cwd) {
       ["-c", makeDependencyCheckCode(dependency)],
       {
         stdio: "pipe",
-        cwd
+        cwd,
+        env: { ...process.env, PYTHONPATH: (0, import_path.join)(cwd, resolveVendorDir()) }
       }
     );
     return stdout.startsWith(cwd);
@@ -2790,7 +2792,8 @@ async function areRequirementsInstalled(pythonPath, requirementsPath, cwd) {
       ["-c", makeRequirementsCheckCode(requirementsPath)],
       {
         stdio: "pipe",
-        cwd
+        cwd,
+        env: { ...process.env, PYTHONPATH: (0, import_path.join)(cwd, resolveVendorDir()) }
       }
     );
     return true;
@@ -2798,13 +2801,18 @@ async function areRequirementsInstalled(pythonPath, requirementsPath, cwd) {
     return false;
   }
 }
+function resolveVendorDir() {
+  const vendorDir = process.env.VERCEL_PYTHON_VENDOR_DIR || "_vendor";
+  return vendorDir;
+}
 async function pipInstall(pipPath, workPath, args) {
-  const target = ".";
+  const target = resolveVendorDir();
   process.env.PIP_USER = "0";
   const cmdArgs = [
     "install",
     "--disable-pip-version-check",
     "--no-compile",
+    "--no-cache-dir",
     "--target",
     target,
     ...args
@@ -2959,14 +2967,32 @@ function isInstalled2({ pipPath, pythonPath }) {
 // src/index.ts
 var readFile = (0, import_util.promisify)(import_fs.default.readFile);
 var writeFile = (0, import_util.promisify)(import_fs.default.writeFile);
-async function pipenvConvert(cmd, srcDir) {
+var fastapiEntrypointFilenames = ["app", "index", "server", "main"];
+var fastapiEntrypointDirs = ["", "src", "app"];
+var fastapiContentRegex = /(from\s+fastapi\s+import\s+FastAPI|import\s+fastapi|FastAPI\s*\()/;
+var fastapiCandidateEntrypoints = fastapiEntrypointFilenames.flatMap(
+  (filename) => fastapiEntrypointDirs.map((dir) => import_path2.posix.join(dir, `${filename}.py`))
+);
+function isFastapiEntrypoint(file) {
+  try {
+    const fsPath = file.fsPath;
+    if (!fsPath)
+      return false;
+    const contents = import_fs.default.readFileSync(fsPath, "utf8");
+    return fastapiContentRegex.test(contents);
+  } catch {
+    return false;
+  }
+}
+async function pipenvConvert(cmd, srcDir, env) {
   (0, import_build_utils3.debug)("Running pipfile2req...");
   try {
     const out = await import_execa2.default.stdout(cmd, [], {
-      cwd: srcDir
+      cwd: srcDir,
+      env
     });
     (0, import_build_utils3.debug)("Contents of requirements.txt is: " + out);
-    import_fs.default.writeFileSync((0, import_path.join)(srcDir, "requirements.txt"), out);
+    import_fs.default.writeFileSync((0, import_path2.join)(srcDir, "requirements.txt"), out);
   } catch (err) {
     console.log('Failed to run "pipfile2req"');
     throw err;
@@ -2982,8 +3008,8 @@ async function downloadFilesInWorkPath({
   (0, import_build_utils3.debug)("Downloading user files...");
   let downloadedFiles = await (0, import_build_utils3.download)(files, workPath, meta);
   if (meta.isDev) {
-    const { devCacheDir = (0, import_path.join)(workPath, ".now", "cache") } = meta;
-    const destCache = (0, import_path.join)(devCacheDir, (0, import_path.basename)(entrypoint, ".py"));
+    const { devCacheDir = (0, import_path2.join)(workPath, ".now", "cache") } = meta;
+    const destCache = (0, import_path2.join)(devCacheDir, (0, import_path2.basename)(entrypoint, ".py"));
     await (0, import_build_utils3.download)(downloadedFiles, destCache);
     downloadedFiles = await (0, import_build_utils3.glob)("**", destCache);
     workPath = destCache;
@@ -3006,57 +3032,120 @@ var build = async ({
   });
   try {
     if (meta.isDev) {
-      const setupCfg = (0, import_path.join)(workPath, "setup.cfg");
+      const setupCfg = (0, import_path2.join)(workPath, "setup.cfg");
       await writeFile(setupCfg, "[install]\nprefix=\n");
     }
   } catch (err) {
     console.log('Failed to create "setup.cfg" file');
     throw err;
   }
+  let fsFiles = await (0, import_build_utils3.glob)("**", workPath);
+  if (!fsFiles[entrypoint]) {
+    let discovered;
+    if (config?.framework === "fastapi") {
+      const entrypointCandidates = fastapiCandidateEntrypoints.filter(
+        (c) => !!fsFiles[c]
+      );
+      if (entrypointCandidates.length) {
+        const fastapiEntrypoint = entrypointCandidates.find(
+          (c) => isFastapiEntrypoint(fsFiles[c])
+        );
+        discovered = fastapiEntrypoint || entrypointCandidates[0];
+      }
+    }
+    if (discovered) {
+      (0, import_build_utils3.debug)(
+        `Resolved Python entrypoint to "${discovered}" (configured "${entrypoint}" not found).`
+      );
+      entrypoint = discovered;
+    } else if (config?.framework === "fastapi") {
+      const searchedList = fastapiCandidateEntrypoints.join(", ");
+      throw new import_build_utils3.NowBuildError({
+        code: "FASTAPI_ENTRYPOINT_NOT_FOUND",
+        message: `No FastAPI entrypoint found. Searched for: ${searchedList}`
+      });
+    }
+  }
+  const entryDirectory = (0, import_path2.dirname)(entrypoint);
+  const hasReqLocal = !!fsFiles[(0, import_path2.join)(entryDirectory, "requirements.txt")];
+  const hasReqGlobal = !!fsFiles["requirements.txt"];
+  const pipfileLockDir = fsFiles[(0, import_path2.join)(entryDirectory, "Pipfile.lock")] ? (0, import_path2.join)(workPath, entryDirectory) : fsFiles["Pipfile.lock"] ? workPath : null;
+  const pipfileDir = fsFiles[(0, import_path2.join)(entryDirectory, "Pipfile")] ? (0, import_path2.join)(workPath, entryDirectory) : fsFiles["Pipfile"] ? workPath : null;
+  if (!hasReqLocal && !hasReqGlobal && (pipfileLockDir || pipfileDir)) {
+    if (pipfileLockDir) {
+      (0, import_build_utils3.debug)('Found "Pipfile.lock"');
+    } else {
+      (0, import_build_utils3.debug)('Found "Pipfile"');
+    }
+    if (pipfileLockDir) {
+      let lock = {};
+      try {
+        const json = await readFile(
+          (0, import_path2.join)(pipfileLockDir, "Pipfile.lock"),
+          "utf8"
+        );
+        lock = JSON.parse(json);
+      } catch (err) {
+        throw new import_build_utils3.NowBuildError({
+          code: "INVALID_PIPFILE_LOCK",
+          message: "Unable to parse Pipfile.lock"
+        });
+      }
+      pythonVersion = getSupportedPythonVersion({
+        isDev: meta.isDev,
+        pipLockPythonVersion: lock?._meta?.requires?.python_version
+      });
+    }
+    if (!hasReqLocal && !hasReqGlobal) {
+      const tempDir = await (0, import_build_utils3.getWriteableDirectory)();
+      await installRequirement({
+        pythonPath: pythonVersion.pythonPath,
+        pipPath: pythonVersion.pipPath,
+        dependency: "pipfile-requirements",
+        version: "0.3.0",
+        workPath: tempDir,
+        meta,
+        args: ["--no-warn-script-location"]
+      });
+      const tempVendorDir = (0, import_path2.join)(tempDir, resolveVendorDir());
+      const envForConvert = { ...process.env, PYTHONPATH: tempVendorDir };
+      const convertCmd = process.platform === "win32" ? (0, import_path2.join)(tempVendorDir, "Scripts", "pipfile2req.exe") : (0, import_path2.join)(tempVendorDir, "bin", "pipfile2req");
+      await pipenvConvert(
+        convertCmd,
+        pipfileLockDir || pipfileDir,
+        envForConvert
+      );
+    } else {
+      (0, import_build_utils3.debug)(
+        'Skipping Pipfile.lock conversion because "requirements.txt" exists'
+      );
+    }
+  }
+  fsFiles = await (0, import_build_utils3.glob)("**", workPath);
+  const requirementsTxt = (0, import_path2.join)(entryDirectory, "requirements.txt");
+  const vendorBaseDir = (0, import_path2.join)(
+    workPath,
+    ".vercel",
+    "cache",
+    "python",
+    `py${pythonVersion.version}`,
+    entryDirectory
+  );
+  try {
+    await import_fs.default.promises.mkdir(vendorBaseDir, { recursive: true });
+  } catch (err) {
+    console.log("Failed to create vendor cache directory");
+    throw err;
+  }
   console.log("Installing required dependencies...");
   await installRequirement({
     pythonPath: pythonVersion.pythonPath,
     pipPath: pythonVersion.pipPath,
     dependency: "werkzeug",
     version: "1.0.1",
-    workPath,
+    workPath: vendorBaseDir,
     meta
   });
-  let fsFiles = await (0, import_build_utils3.glob)("**", workPath);
-  const entryDirectory = (0, import_path.dirname)(entrypoint);
-  const pipfileLockDir = fsFiles[(0, import_path.join)(entryDirectory, "Pipfile.lock")] ? (0, import_path.join)(workPath, entryDirectory) : fsFiles["Pipfile.lock"] ? workPath : null;
-  if (pipfileLockDir) {
-    (0, import_build_utils3.debug)('Found "Pipfile.lock"');
-    let lock = {};
-    try {
-      const json = await readFile((0, import_path.join)(pipfileLockDir, "Pipfile.lock"), "utf8");
-      lock = JSON.parse(json);
-    } catch (err) {
-      throw new import_build_utils3.NowBuildError({
-        code: "INVALID_PIPFILE_LOCK",
-        message: "Unable to parse Pipfile.lock"
-      });
-    }
-    pythonVersion = getSupportedPythonVersion({
-      isDev: meta.isDev,
-      pipLockPythonVersion: lock?._meta?.requires?.python_version
-    });
-    const tempDir = await (0, import_build_utils3.getWriteableDirectory)();
-    await installRequirement({
-      pythonPath: pythonVersion.pythonPath,
-      pipPath: pythonVersion.pipPath,
-      dependency: "pipfile-requirements",
-      version: "0.3.0",
-      workPath: tempDir,
-      meta,
-      args: ["--no-warn-script-location"]
-    });
-    process.env.PYTHONPATH = tempDir;
-    const convertCmd = (0, import_path.join)(tempDir, "bin", "pipfile2req");
-    await pipenvConvert(convertCmd, pipfileLockDir);
-  }
-  fsFiles = await (0, import_build_utils3.glob)("**", workPath);
-  const requirementsTxt = (0, import_path.join)(entryDirectory, "requirements.txt");
   if (fsFiles[requirementsTxt]) {
     (0, import_build_utils3.debug)('Found local "requirements.txt"');
     const requirementsTxtPath = fsFiles[requirementsTxt].fsPath;
@@ -3064,7 +3153,7 @@ var build = async ({
       pythonPath: pythonVersion.pythonPath,
       pipPath: pythonVersion.pipPath,
       filePath: requirementsTxtPath,
-      workPath,
+      workPath: vendorBaseDir,
       meta
     });
   } else if (fsFiles["requirements.txt"]) {
@@ -3074,20 +3163,22 @@ var build = async ({
       pythonPath: pythonVersion.pythonPath,
       pipPath: pythonVersion.pipPath,
       filePath: requirementsTxtPath,
-      workPath,
+      workPath: vendorBaseDir,
       meta
     });
   }
-  const originalPyPath = (0, import_path.join)(__dirname, "..", "vc_init.py");
+  const originalPyPath = (0, import_path2.join)(__dirname, "..", "vc_init.py");
   const originalHandlerPyContents = await readFile(originalPyPath, "utf8");
   (0, import_build_utils3.debug)("Entrypoint is", entrypoint);
   const moduleName = entrypoint.replace(/\//g, ".").replace(/\.py$/, "");
+  const vendorDir = resolveVendorDir();
   const suffix = meta.isDev && !entrypoint.endsWith(".py") ? ".py" : "";
   const entrypointWithSuffix = `${entrypoint}${suffix}`;
   (0, import_build_utils3.debug)("Entrypoint with suffix is", entrypointWithSuffix);
-  const handlerPyContents = originalHandlerPyContents.replace(/__VC_HANDLER_MODULE_NAME/g, moduleName).replace(/__VC_HANDLER_ENTRYPOINT/g, entrypointWithSuffix);
+  const handlerPyContents = originalHandlerPyContents.replace(/__VC_HANDLER_MODULE_NAME/g, moduleName).replace(/__VC_HANDLER_ENTRYPOINT/g, entrypointWithSuffix).replace(/__VC_HANDLER_VENDOR_DIR/g, vendorDir);
   const predefinedExcludes = [
     ".git/**",
+    ".gitignore",
     ".vercel/**",
     ".pnpm-store/**",
     "**/node_modules/**",
@@ -3097,11 +3188,25 @@ var build = async ({
     "**/venv/**",
     "**/__pycache__/**"
   ];
+  const lambdaEnv = {};
+  lambdaEnv.PYTHONPATH = vendorDir;
   const globOptions = {
     cwd: workPath,
     ignore: config && typeof config.excludeFiles === "string" ? [...predefinedExcludes, config.excludeFiles] : predefinedExcludes
   };
   const files = await (0, import_build_utils3.glob)("**", globOptions);
+  try {
+    const cachedVendorAbs = (0, import_path2.join)(vendorBaseDir, resolveVendorDir());
+    if (import_fs.default.existsSync(cachedVendorAbs)) {
+      const vendorFiles = await (0, import_build_utils3.glob)("**", cachedVendorAbs, resolveVendorDir());
+      for (const [p, f] of Object.entries(vendorFiles)) {
+        files[p] = f;
+      }
+    }
+  } catch (err) {
+    console.log("Failed to include cached vendor directory");
+    throw err;
+  }
   const handlerPyFilename = "vc__handler__python";
   files[`${handlerPyFilename}.py`] = new import_build_utils3.FileBlob({ data: handlerPyContents });
   if (config.framework === "fasthtml") {
@@ -3112,7 +3217,7 @@ var build = async ({
     files,
     handler: `${handlerPyFilename}.vc_handler`,
     runtime: pythonVersion.runtime,
-    environment: {},
+    environment: lambdaEnv,
     supportsResponseStreaming: true
   });
   return { output };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/python",
-  "version": "5.0.1",
+  "version": "5.0.3",
   "main": "./dist/index.js",
   "license": "Apache-2.0",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/python",

package/vc_init.py

@@ -1,14 +1,38 @@
 import sys
+import os
+import site
+import importlib
 import base64
 import json
 import inspect
 from importlib import util
 from http.server import BaseHTTPRequestHandler
 import socket
-import os
+
+_here = os.path.dirname(__file__)
+_vendor_rel = '__VC_HANDLER_VENDOR_DIR'
+_vendor = os.path.normpath(os.path.join(_here, _vendor_rel))
+
+if os.path.isdir(_vendor):
+    # Process .pth files like a real site-packages dir
+    site.addsitedir(_vendor)
+
+    # Move _vendor to the front (after script dir if present)
+    try:
+        while _vendor in sys.path:
+            sys.path.remove(_vendor)
+    except ValueError:
+        pass
+
+    # Put vendored deps ahead of site-packages but after the script dir
+    idx = 1 if (sys.path and sys.path[0] in ('', _here)) else 0
+    sys.path.insert(idx, _vendor)
+
+    importlib.invalidate_caches()
 
 # Import relative path https://docs.python.org/3/library/importlib.html#importing-a-source-file-directly
-__vc_spec = util.spec_from_file_location("__VC_HANDLER_MODULE_NAME", "./__VC_HANDLER_ENTRYPOINT")
+user_mod_path = os.path.join(_here, "__VC_HANDLER_ENTRYPOINT")  # absolute
+__vc_spec = util.spec_from_file_location("__VC_HANDLER_MODULE_NAME", user_mod_path)
 __vc_module = util.module_from_spec(__vc_spec)
 sys.modules["__VC_HANDLER_MODULE_NAME"] = __vc_module
 __vc_spec.loader.exec_module(__vc_module)