@vercel/python 5.0.6 → 5.0.7

package/dist/index.js

@@ -2836,16 +2836,10 @@ async function getUserScriptsDir(pythonPath) {
     return null;
   }
 }
-async function pipInstall(pipPath, pythonPath, workPath, args, targetDir) {
+async function pipInstall(pipPath, uvPath, workPath, args, targetDir) {
   const target = targetDir ? (0, import_path.join)(targetDir, resolveVendorDir()) : resolveVendorDir();
   process.env.PIP_USER = "0";
-  let uvBin = null;
-  try {
-    uvBin = await getUvBinaryOrInstall(pythonPath);
-  } catch (err) {
-    console.log("Failed to install uv, falling back to pip");
-  }
-  if (uvBin) {
+  if (uvPath) {
     const uvArgs = [
       "pip",
       "install",
@@ -2855,10 +2849,10 @@ async function pipInstall(pipPath, pythonPath, workPath, args, targetDir) {
       target,
       ...args
     ];
-    const prettyUv = `${uvBin} ${uvArgs.join(" ")}`;
+    const prettyUv = `${uvPath} ${uvArgs.join(" ")}`;
     (0, import_build_utils.debug)(`Running "${prettyUv}"...`);
     try {
-      await (0, import_execa.default)(uvBin, uvArgs, {
+      await (0, import_execa.default)(uvPath, uvArgs, {
         cwd: workPath
       });
       return;
@@ -2932,10 +2926,8 @@ async function maybeFindUvBin(pythonPath) {
 }
 async function getUvBinaryOrInstall(pythonPath) {
   const uvBin = await maybeFindUvBin(pythonPath);
-  if (uvBin) {
-    console.log(`Using uv at "${uvBin}"`);
+  if (uvBin)
     return uvBin;
-  }
   try {
     console.log("Installing uv...");
     await (0, import_execa.default)(
@@ -2966,6 +2958,7 @@ async function getUvBinaryOrInstall(pythonPath) {
 async function installRequirement({
   pythonPath,
   pipPath,
+  uvPath,
   dependency,
   version: version2,
   workPath,
@@ -2981,11 +2974,12 @@ async function installRequirement({
     return;
   }
   const exact = `${dependency}==${version2}`;
-  await pipInstall(pipPath, pythonPath, workPath, [exact, ...args], targetDir);
+  await pipInstall(pipPath, uvPath, workPath, [exact, ...args], targetDir);
 }
 async function installRequirementsFile({
   pythonPath,
   pipPath,
+  uvPath,
   filePath,
   workPath,
   targetDir,
@@ -2999,27 +2993,29 @@ async function installRequirementsFile({
   }
   await pipInstall(
     pipPath,
-    pythonPath,
+    uvPath,
     workPath,
     ["--upgrade", "-r", filePath, ...args],
     targetDir
   );
 }
-async function exportRequirementsFromUv(pythonPath, projectDir, options = {}) {
+async function exportRequirementsFromUv(projectDir, uvPath, options = {}) {
   const { locked = false } = options;
-  const uvBin = await getUvBinaryOrInstall(pythonPath);
+  if (!uvPath) {
+    throw new Error("uv is not available to export requirements");
+  }
   const args = ["export"];
   if (locked) {
     args.push("--frozen");
   }
-  (0, import_build_utils.debug)(`Running "${uvBin} ${args.join(" ")}" in ${projectDir}...`);
+  (0, import_build_utils.debug)(`Running "${uvPath} ${args.join(" ")}" in ${projectDir}...`);
   let stdout;
   try {
-    const { stdout: out } = await (0, import_execa.default)(uvBin, args, { cwd: projectDir });
+    const { stdout: out } = await (0, import_execa.default)(uvPath, args, { cwd: projectDir });
     stdout = out;
   } catch (err) {
     throw new Error(
-      `Failed to run "${uvBin} ${args.join(" ")}": ${err instanceof Error ? err.message : String(err)}`
+      `Failed to run "${uvPath} ${args.join(" ")}": ${err instanceof Error ? err.message : String(err)}`
     );
   }
   const tmpDir = await import_fs.default.promises.mkdtemp((0, import_path.join)(import_os.default.tmpdir(), "vercel-uv-"));
@@ -3031,6 +3027,7 @@ async function exportRequirementsFromUv(pythonPath, projectDir, options = {}) {
 async function exportRequirementsFromPipfile({
   pythonPath,
   pipPath,
+  uvPath,
   projectDir,
   meta
 }) {
@@ -3044,7 +3041,8 @@ async function exportRequirementsFromPipfile({
     version: "0.3.0",
     workPath: tempDir,
     meta,
-    args: ["--no-warn-script-location"]
+    args: ["--no-warn-script-location"],
+    uvPath
   });
   const tempVendorDir = (0, import_path.join)(tempDir, resolveVendorDir());
   const convertCmd = isWin ? (0, import_path.join)(tempVendorDir, "Scripts", "pipfile2req.exe") : (0, import_path.join)(tempVendorDir, "bin", "pipfile2req");
@@ -3151,16 +3149,27 @@ function getSupportedPythonVersion({
       }
       if (isInstalled2(requested)) {
         selection = requested;
+        console.log(`Using Python ${selection.version} from ${source}`);
       } else {
         console.warn(
           `Warning: Python version "${version2}" detected in ${source} is not installed and will be ignored. http://vercel.link/python-version`
         );
+        console.log(
+          `Falling back to latest installed version: ${selection.version}`
+        );
       }
     } else {
       console.warn(
         `Warning: Python version "${version2}" detected in ${source} is invalid and will be ignored. http://vercel.link/python-version`
       );
+      console.log(
+        `Falling back to latest installed version: ${selection.version}`
+      );
     }
+  } else {
+    console.log(
+      `No Python version specified in pyproject.toml or Pipfile.lock. Using latest installed version: ${selection.version}`
+    );
   }
   if (isDiscontinued(selection)) {
     throw new import_build_utils2.NowBuildError({
@@ -3606,7 +3615,6 @@ var build = async ({
   meta = {},
   config
 }) => {
-  let pythonVersion = getLatestPythonVersion(meta);
   workPath = await downloadFilesInWorkPath({
     workPath,
     files: originalFiles,
@@ -3655,22 +3663,26 @@ var build = async ({
   });
   const pipfileLockDir = fsFiles[(0, import_path5.join)(entryDirectory, "Pipfile.lock")] ? (0, import_path5.join)(workPath, entryDirectory) : fsFiles["Pipfile.lock"] ? workPath : null;
   const pipfileDir = fsFiles[(0, import_path5.join)(entryDirectory, "Pipfile")] ? (0, import_path5.join)(workPath, entryDirectory) : fsFiles["Pipfile"] ? workPath : null;
+  let declaredPythonVersion;
   if (pyprojectDir) {
     let requiresPython;
     try {
       const pyproject = await (0, import_build_utils6.readConfigFile)((0, import_path5.join)(pyprojectDir, "pyproject.toml"));
       requiresPython = pyproject?.project?.["requires-python"];
-    } catch {
-      (0, import_build_utils5.debug)("Failed to parse pyproject.toml");
+    } catch (err) {
+      (0, import_build_utils5.debug)("Failed to parse pyproject.toml", err);
     }
     const VERSION_REGEX = /\b\d+\.\d+\b/;
     const exact = requiresPython?.trim().match(VERSION_REGEX)?.[0];
     if (exact) {
-      const selected = getSupportedPythonVersion({
-        isDev: meta.isDev,
-        declaredPythonVersion: { version: exact, source: "pyproject.toml" }
-      });
-      pythonVersion = selected;
+      declaredPythonVersion = { version: exact, source: "pyproject.toml" };
+      (0, import_build_utils5.debug)(
+        `Found Python version ${exact} in pyproject.toml (requires-python: "${requiresPython}")`
+      );
+    } else if (requiresPython) {
+      (0, import_build_utils5.debug)(
+        `Could not parse Python version from pyproject.toml requires-python: "${requiresPython}"`
+      );
     }
   } else if (pipfileLockDir) {
     let lock = {};
@@ -3684,11 +3696,15 @@ var build = async ({
       });
     }
     const pyFromLock = lock?._meta?.requires?.python_version;
-    pythonVersion = getSupportedPythonVersion({
-      isDev: meta.isDev,
-      declaredPythonVersion: pyFromLock ? { version: pyFromLock, source: "Pipfile.lock" } : void 0
-    });
+    if (pyFromLock) {
+      declaredPythonVersion = { version: pyFromLock, source: "Pipfile.lock" };
+      (0, import_build_utils5.debug)(`Found Python version ${pyFromLock} in Pipfile.lock`);
+    }
   }
+  const pythonVersion = getSupportedPythonVersion({
+    isDev: meta.isDev,
+    declaredPythonVersion
+  });
   fsFiles = await (0, import_build_utils5.glob)("**", workPath);
   const requirementsTxt = (0, import_path5.join)(entryDirectory, "requirements.txt");
   const vendorBaseDir = (0, import_path5.join)(
@@ -3704,10 +3720,42 @@ var build = async ({
     console.log("Failed to create vendor cache directory");
     throw err;
   }
-  console.log("Installing required dependencies...");
+  let installationSource;
+  if (uvLockDir && pyprojectDir) {
+    installationSource = "uv.lock";
+  } else if (pyprojectDir) {
+    installationSource = "pyproject.toml";
+  } else if (pipfileLockDir) {
+    installationSource = "Pipfile.lock";
+  } else if (pipfileDir) {
+    installationSource = "Pipfile";
+  } else if (fsFiles[requirementsTxt] || fsFiles["requirements.txt"]) {
+    installationSource = "requirements.txt";
+  }
+  if (installationSource) {
+    console.log(
+      `Installing required dependencies from ${installationSource}...`
+    );
+  } else {
+    console.log("Installing required dependencies...");
+  }
+  let uvPath = null;
+  try {
+    uvPath = await getUvBinaryOrInstall(pythonVersion.pythonPath);
+    console.log(`Using uv at "${uvPath}"`);
+  } catch (err) {
+    if (uvLockDir || pyprojectDir && !hasReqLocal && !hasReqGlobal) {
+      console.log("Failed to install uv");
+      throw new Error(
+        `uv is required for this project but failed to install: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    (0, import_build_utils5.debug)("Failed to install uv", err);
+  }
   await installRequirement({
     pythonPath: pythonVersion.pythonPath,
     pipPath: pythonVersion.pipPath,
+    uvPath,
     dependency: "werkzeug",
     version: "1.0.1",
     workPath,
@@ -3718,14 +3766,13 @@ var build = async ({
   if (uvLockDir) {
     (0, import_build_utils5.debug)('Found "uv.lock"');
     if (pyprojectDir) {
-      const exportedReq = await exportRequirementsFromUv(
-        pythonVersion.pythonPath,
-        pyprojectDir,
-        { locked: true }
-      );
+      const exportedReq = await exportRequirementsFromUv(pyprojectDir, uvPath, {
+        locked: true
+      });
       await installRequirementsFile({
         pythonPath: pythonVersion.pythonPath,
         pipPath: pythonVersion.pipPath,
+        uvPath,
         filePath: exportedReq,
         workPath,
         targetDir: vendorBaseDir,
@@ -3742,14 +3789,13 @@ var build = async ({
         "Detected both pyproject.toml and requirements.txt but no lockfile; using pyproject.toml"
       );
     }
-    const exportedReq = await exportRequirementsFromUv(
-      pythonVersion.pythonPath,
-      pyprojectDir,
-      { locked: false }
-    );
+    const exportedReq = await exportRequirementsFromUv(pyprojectDir, uvPath, {
+      locked: false
+    });
     await installRequirementsFile({
       pythonPath: pythonVersion.pythonPath,
       pipPath: pythonVersion.pipPath,
+      uvPath,
       filePath: exportedReq,
       workPath,
       targetDir: vendorBaseDir,
@@ -3764,12 +3810,14 @@ var build = async ({
       const exportedReq = await exportRequirementsFromPipfile({
         pythonPath: pythonVersion.pythonPath,
         pipPath: pythonVersion.pipPath,
+        uvPath,
         projectDir: pipfileLockDir || pipfileDir,
         meta
       });
       await installRequirementsFile({
         pythonPath: pythonVersion.pythonPath,
         pipPath: pythonVersion.pipPath,
+        uvPath,
         filePath: exportedReq,
         workPath,
         targetDir: vendorBaseDir,
@@ -3784,6 +3832,7 @@ var build = async ({
     await installRequirementsFile({
       pythonPath: pythonVersion.pythonPath,
       pipPath: pythonVersion.pipPath,
+      uvPath,
       filePath: requirementsTxtPath,
       workPath,
       targetDir: vendorBaseDir,
@@ -3795,6 +3844,7 @@ var build = async ({
     await installRequirementsFile({
       pythonPath: pythonVersion.pythonPath,
       pipPath: pythonVersion.pipPath,
+      uvPath,
       filePath: requirementsTxtPath,
       workPath,
       targetDir: vendorBaseDir,

package/package.json

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

package/vc_init.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sys
 import os
 import site
@@ -7,9 +8,17 @@ import json
 import inspect
 import threading
 import asyncio
+import http
+import time
 from importlib import util
-from http.server import BaseHTTPRequestHandler
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 import socket
+import functools
+import logging
+import builtins
+from typing import Callable, Literal
+import contextvars
+import io
 
 _here = os.path.dirname(__file__)
 _vendor_rel = '__VC_HANDLER_VENDOR_DIR'
@@ -53,72 +62,69 @@ def format_headers(headers, decode=False):
         keyToList[key].append(value)
     return keyToList
 
-if 'VERCEL_IPC_PATH' in os.environ:
-    from http.server import ThreadingHTTPServer
-    import http
-    import time
-    import contextvars
-    import functools
-    import builtins
-    import logging
+# Custom logging handler so logs are properly categorized
+class VCLogHandler(logging.Handler):
+    def __init__(self, send_message: Callable[[dict], None], context_getter: Callable[[], dict] | None = None):
+        super().__init__()
+        self._send_message = send_message
+        self._context_getter = context_getter
 
-    start_time = time.time()
-    sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-    sock.connect(os.getenv("VERCEL_IPC_PATH", ""))
+    def emit(self, record):
+        try:
+            message = record.getMessage()
+        except Exception:
+            try:
+                message = f"{record.msg}"
+            except Exception:
+                message = ""
+
+        if record.levelno >= logging.CRITICAL:
+            level = "fatal"
+        elif record.levelno >= logging.ERROR:
+            level = "error"
+        elif record.levelno >= logging.WARNING:
+            level = "warn"
+        elif record.levelno >= logging.INFO:
+            level = "info"
+        else:
+            level = "debug"
 
-    send_message = lambda message: sock.sendall((json.dumps(message) + '\0').encode())
-    storage = contextvars.ContextVar('storage', default=None)
+        ctx = None
+        try:
+            ctx = self._context_getter() if self._context_getter is not None else None
+        except Exception:
+            ctx = None
 
-    # Override urlopen from urllib3 (& requests) to send Request Metrics
-    try:
-        import urllib3
-        from urllib.parse import urlparse
+        if ctx is not None:
+            try:
+                self._send_message({
+                    "type": "log",
+                    "payload": {
+                        "context": {
+                            "invocationId": ctx['invocationId'],
+                            "requestId": ctx['requestId'],
+                        },
+                        "message": base64.b64encode(message.encode()).decode(),
+                        "level": level,
+                    }
+                })
+            except Exception:
+                pass
+        else:
+            try:
+                sys.stdout.write(message + "\n")
+            except Exception:
+                pass
 
-        def timed_request(func):
-            fetchId = 0
-            @functools.wraps(func)
-            def wrapper(self, method, url, *args, **kwargs):
-                nonlocal fetchId
-                fetchId += 1
-                start_time = int(time.time() * 1000)
-                result = func(self, method, url, *args, **kwargs)
-                elapsed_time = int(time.time() * 1000) - start_time
-                parsed_url = urlparse(url)
-                context = storage.get()
-                if context is not None:
-                    send_message({
-                        "type": "metric",
-                        "payload": {
-                            "context": {
-                                "invocationId": context['invocationId'],
-                                "requestId": context['requestId'],
-                            },
-                            "type": "fetch-metric",
-                            "payload": {
-                                "pathname": parsed_url.path,
-                                "search": parsed_url.query,
-                                "start": start_time,
-                                "duration": elapsed_time,
-                                "host": parsed_url.hostname or self.host,
-                                "statusCode": result.status,
-                                "method": method,
-                                "id": fetchId
-                            }
-                        }
-                    })
-                return result
-            return wrapper
-        urllib3.connectionpool.HTTPConnectionPool.urlopen = timed_request(urllib3.connectionpool.HTTPConnectionPool.urlopen)
-    except:
-        pass
 
+def setup_logging(send_message: Callable[[dict], None], storage: contextvars.ContextVar[dict | None]):
     # Override sys.stdout and sys.stderr to map logs to the correct request
     class StreamWrapper:
-        def __init__(self, stream, stream_name):
+        def __init__(self, stream: io.TextIOBase, stream_name: Literal["stdout", "stderr"]):
             self.stream = stream
             self.stream_name = stream_name
 
-        def write(self, message):
+        def write(self, message: str):
             context = storage.get()
             if context is not None:
                 send_message({
@@ -141,19 +147,15 @@ if 'VERCEL_IPC_PATH' in os.environ:
     sys.stdout = StreamWrapper(sys.stdout, "stdout")
     sys.stderr = StreamWrapper(sys.stderr, "stderr")
 
-    # Override the global print to log to stdout
-    def print_wrapper(func):
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            sys.stdout.write(' '.join(map(str, args)) + '\n')
-        return wrapper
-    builtins.print = print_wrapper(builtins.print)
-
-    # Override logging to maps logs to the correct request
-    def logging_wrapper(func, level="info"):
+    # Wrap top-level logging helpers to emit structured logs when a request
+    # context is available; otherwise fall back to the original behavior.
+    def logging_wrapper(func: Callable[..., None], level: str = "info") -> Callable[..., None]:
         @functools.wraps(func)
         def wrapper(*args, **kwargs):
-            context = storage.get()
+            try:
+                context = storage.get()
+            except Exception:
+                context = None
             if context is not None:
                 send_message({
                     "type": "log",
@@ -170,12 +172,77 @@ if 'VERCEL_IPC_PATH' in os.environ:
                 func(*args, **kwargs)
         return wrapper
 
-    logging.basicConfig(level=logging.INFO)
-    logging.debug = logging_wrapper(logging.debug)
-    logging.info = logging_wrapper(logging.info)
+    logging.basicConfig(level=logging.INFO, handlers=[VCLogHandler(send_message, storage.get)], force=True)
+    logging.debug = logging_wrapper(logging.debug, "debug")
+    logging.info = logging_wrapper(logging.info, "info")
     logging.warning = logging_wrapper(logging.warning, "warn")
     logging.error = logging_wrapper(logging.error, "error")
-    logging.critical = logging_wrapper(logging.critical, "error")
+    logging.fatal = logging_wrapper(logging.fatal, "fatal")
+    logging.critical = logging_wrapper(logging.critical, "fatal")
+
+    # Ensure built-in print funnels through stdout wrapper so prints are
+    # attributed to the current request context.
+    def print_wrapper(func: Callable[..., None]) -> Callable[..., None]:
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            sys.stdout.write(' '.join(map(str, args)) + '\n')
+        return wrapper
+
+    builtins.print = print_wrapper(builtins.print)
+
+
+if 'VERCEL_IPC_PATH' in os.environ:
+    start_time = time.time()
+    sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+    sock.connect(os.getenv("VERCEL_IPC_PATH", ""))
+
+    send_message = lambda message: sock.sendall((json.dumps(message) + '\0').encode())
+    storage = contextvars.ContextVar('storage', default=None)
+
+    # Override urlopen from urllib3 (& requests) to send Request Metrics
+    try:
+        import urllib3
+        from urllib.parse import urlparse
+
+        def timed_request(func):
+            fetchId = 0
+            @functools.wraps(func)
+            def wrapper(self, method, url, *args, **kwargs):
+                nonlocal fetchId
+                fetchId += 1
+                start_time = int(time.time() * 1000)
+                result = func(self, method, url, *args, **kwargs)
+                elapsed_time = int(time.time() * 1000) - start_time
+                parsed_url = urlparse(url)
+                context = storage.get()
+                if context is not None:
+                    send_message({
+                        "type": "metric",
+                        "payload": {
+                            "context": {
+                                "invocationId": context['invocationId'],
+                                "requestId": context['requestId'],
+                            },
+                            "type": "fetch-metric",
+                            "payload": {
+                                "pathname": parsed_url.path,
+                                "search": parsed_url.query,
+                                "start": start_time,
+                                "duration": elapsed_time,
+                                "host": parsed_url.hostname or self.host,
+                                "statusCode": result.status,
+                                "method": method,
+                                "id": fetchId
+                            }
+                        }
+                    })
+                return result
+            return wrapper
+        urllib3.connectionpool.HTTPConnectionPool.urlopen = timed_request(urllib3.connectionpool.HTTPConnectionPool.urlopen)
+    except:
+        pass
+
+    setup_logging(send_message, storage)
 
     class BaseHandler(BaseHTTPRequestHandler):
         # Re-implementation of BaseHTTPRequestHandler's log_message method to