@vercel/python 6.22.0 → 6.23.0

package/dist/index.js

@@ -48,7 +48,7 @@ var require_windows = __commonJS({
   "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js"(exports, module2) {
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs9 = require("fs");
+    var fs10 = require("fs");
     function checkPathExt(path, options) {
       var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
       if (!pathext) {
@@ -73,12 +73,12 @@ var require_windows = __commonJS({
       return checkPathExt(path, options);
     }
     function isexe(path, options, cb) {
-      fs9.stat(path, function(er, stat) {
+      fs10.stat(path, function(er, stat) {
         cb(er, er ? false : checkStat(stat, path, options));
       });
     }
     function sync(path, options) {
-      return checkStat(fs9.statSync(path), path, options);
+      return checkStat(fs10.statSync(path), path, options);
     }
   }
 });
@@ -88,14 +88,14 @@ var require_mode = __commonJS({
   "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js"(exports, module2) {
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs9 = require("fs");
+    var fs10 = require("fs");
     function isexe(path, options, cb) {
-      fs9.stat(path, function(er, stat) {
+      fs10.stat(path, function(er, stat) {
         cb(er, er ? false : checkStat(stat, options));
       });
     }
     function sync(path, options) {
-      return checkStat(fs9.statSync(path), options);
+      return checkStat(fs10.statSync(path), options);
     }
     function checkStat(stat, options) {
       return stat.isFile() && checkMode(stat, options);
@@ -119,7 +119,7 @@ var require_mode = __commonJS({
 // ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js
 var require_isexe = __commonJS({
   "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js"(exports, module2) {
-    var fs9 = require("fs");
+    var fs10 = require("fs");
     var core;
     if (process.platform === "win32" || global.TESTING_WINDOWS) {
       core = require_windows();
@@ -137,12 +137,12 @@ var require_isexe = __commonJS({
         if (typeof Promise !== "function") {
           throw new TypeError("callback not provided");
         }
-        return new Promise(function(resolve2, reject) {
+        return new Promise(function(resolve3, reject) {
           isexe(path, options || {}, function(er, is) {
             if (er) {
               reject(er);
             } else {
-              resolve2(is);
+              resolve3(is);
             }
           });
         });
@@ -395,7 +395,7 @@ var require_shebang_command = __commonJS({
 var require_readShebang = __commonJS({
   "../../node_modules/.pnpm/cross-spawn@6.0.5/node_modules/cross-spawn/lib/util/readShebang.js"(exports, module2) {
     "use strict";
-    var fs9 = require("fs");
+    var fs10 = require("fs");
     var shebangCommand = require_shebang_command();
     function readShebang(command) {
       const size = 150;
@@ -408,9 +408,9 @@ var require_readShebang = __commonJS({
       }
       let fd;
       try {
-        fd = fs9.openSync(command, "r");
-        fs9.readSync(fd, buffer, 0, size, 0);
-        fs9.closeSync(fd);
+        fd = fs10.openSync(command, "r");
+        fs10.readSync(fd, buffer, 0, size, 0);
+        fs10.closeSync(fd);
       } catch (e) {
       }
       return shebangCommand(buffer.toString());
@@ -1895,9 +1895,9 @@ var require_pump = __commonJS({
   "../../node_modules/.pnpm/pump@3.0.2/node_modules/pump/index.js"(exports, module2) {
     var once = require_once();
     var eos = require_end_of_stream();
-    var fs9;
+    var fs10;
     try {
-      fs9 = require("fs");
+      fs10 = require("fs");
     } catch (e) {
     }
     var noop = function() {
@@ -1909,9 +1909,9 @@ var require_pump = __commonJS({
     var isFS = function(stream) {
       if (!ancient)
         return false;
-      if (!fs9)
+      if (!fs10)
         return false;
-      return (stream instanceof (fs9.ReadStream || noop) || stream instanceof (fs9.WriteStream || noop)) && isFn(stream.close);
+      return (stream instanceof (fs10.ReadStream || noop) || stream instanceof (fs10.WriteStream || noop)) && isFn(stream.close);
     };
     var isRequest = function(stream) {
       return stream.setHeader && isFn(stream.abort);
@@ -2042,7 +2042,7 @@ var require_get_stream = __commonJS({
       options = Object.assign({ maxBuffer: Infinity }, options);
       const { maxBuffer } = options;
       let stream;
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve3, reject) => {
         const rejectPromise = (error) => {
           if (error) {
             error.bufferedData = stream.getBufferedValue();
@@ -2054,7 +2054,7 @@ var require_get_stream = __commonJS({
             rejectPromise(error);
             return;
           }
-          resolve2();
+          resolve3();
         });
         stream.on("data", () => {
           if (stream.getBufferedLength() > maxBuffer) {
@@ -2078,11 +2078,11 @@ var require_p_finally = __commonJS({
       onFinally = onFinally || (() => {
       });
       return promise.then(
-        (val) => new Promise((resolve2) => {
-          resolve2(onFinally());
+        (val) => new Promise((resolve3) => {
+          resolve3(onFinally());
         }).then(() => val),
-        (err) => new Promise((resolve2) => {
-          resolve2(onFinally());
+        (err) => new Promise((resolve3) => {
+          resolve3(onFinally());
         }).then(() => {
           throw err;
         })
@@ -2461,8 +2461,8 @@ var require_execa = __commonJS({
       }
       let ret;
       if (!buffer) {
-        ret = new Promise((resolve2, reject) => {
-          process2[stream].once("end", resolve2).once("error", reject);
+        ret = new Promise((resolve3, reject) => {
+          process2[stream].once("end", resolve3).once("error", reject);
         });
       } else if (encoding) {
         ret = _getStream(process2[stream], {
@@ -2551,19 +2551,19 @@ ${stderr}${stdout}`;
           spawned.kill(parsed.opts.killSignal);
         }, parsed.opts.timeout);
       }
-      const processDone = new Promise((resolve2) => {
+      const processDone = new Promise((resolve3) => {
         spawned.on("exit", (code, signal) => {
           cleanup();
-          resolve2({ code, signal });
+          resolve3({ code, signal });
         });
         spawned.on("error", (err) => {
           cleanup();
-          resolve2({ error: err });
+          resolve3({ error: err });
         });
         if (spawned.stdin) {
           spawned.stdin.on("error", (err) => {
             cleanup();
-            resolve2({ error: err });
+            resolve3({ error: err });
           });
         }
       });
@@ -2751,14 +2751,14 @@ var require_get_port = __commonJS({
     };
     var releaseOldLockedPortsIntervalMs = 1e3 * 15;
     var interval;
-    var getAvailablePort = (options) => new Promise((resolve2, reject) => {
+    var getAvailablePort = (options) => new Promise((resolve3, reject) => {
       const server = net.createServer();
       server.unref();
       server.on("error", reject);
       server.listen(options, () => {
         const { port } = server.address();
         server.close(() => {
-          resolve2(port);
+          resolve3(port);
         });
       });
     });
@@ -2830,7 +2830,7 @@ var require_is_port_reachable = __commonJS({
     "use strict";
     var net = require("net");
     module2.exports = async (port, { timeout = 1e3, host } = {}) => {
-      const promise = new Promise((resolve2, reject) => {
+      const promise = new Promise((resolve3, reject) => {
         const socket = new net.Socket();
         const onError = () => {
           socket.destroy();
@@ -2841,7 +2841,7 @@ var require_is_port_reachable = __commonJS({
         socket.once("timeout", onError);
         socket.connect(port, host, () => {
           socket.end();
-          resolve2();
+          resolve3();
         });
       });
       try {
@@ -2862,7 +2862,6 @@ __export(src_exports, {
   downloadFilesInWorkPath: () => downloadFilesInWorkPath,
   installRequirement: () => installRequirement,
   installRequirementsFile: () => installRequirementsFile,
-  prepareCache: () => prepareCache,
   runFrameworkHook: () => runFrameworkHook,
   shouldServe: () => shouldServe,
   startDevServer: () => startDevServer,
@@ -2904,19 +2903,14 @@ var import_build_utils = require("@vercel/build-utils");
 var UV_VERSION = "0.9.22";
 var UV_PYTHON_PATH_PREFIX = "/uv/python/";
 var UV_PYTHON_DOWNLOADS_MODE = "automatic";
-var UV_CACHE_DIR_SUBPATH = [".vercel", "python", "cache", "uv"];
 var isWin = process.platform === "win32";
 var uvExec = isWin ? "uv.exe" : "uv";
 function findUvInPath() {
   return import_which.default.sync("uv", { nothrow: true });
 }
-function getUvCacheDir(workPath) {
-  return (0, import_path.join)(workPath, ...UV_CACHE_DIR_SUBPATH);
-}
 var UvRunner = class {
-  constructor(uvPath, uvCacheDir) {
+  constructor(uvPath) {
     this.uvPath = uvPath;
-    this.uvCacheDir = uvCacheDir;
   }
   getPath() {
     return this.uvPath;
@@ -2993,7 +2987,7 @@ var UvRunner = class {
     try {
       await (0, import_execa.default)(this.uvPath, args, {
         cwd: projectDir,
-        env: getProtectedUvEnv(process.env, this.uvCacheDir)
+        env: getProtectedUvEnv(process.env)
       });
     } catch (err) {
       const error = new Error(
@@ -3058,7 +3052,7 @@ var UvRunner = class {
     const binDir = isWin ? (0, import_path.join)(venvPath, "Scripts") : (0, import_path.join)(venvPath, "bin");
     const existingPath = process.env.PATH || "";
     return {
-      ...getProtectedUvEnv(process.env, this.uvCacheDir),
+      ...getProtectedUvEnv(process.env),
       VIRTUAL_ENV: venvPath,
       PATH: existingPath ? `${binDir}${import_path2.delimiter}${existingPath}` : binDir
     };
@@ -3165,15 +3159,11 @@ async function getUvBinaryOrInstall(pythonPath) {
 function filterUnsafeUvPipArgs(args) {
   return args.filter((arg) => arg !== "--no-warn-script-location");
 }
-function getProtectedUvEnv(baseEnv = process.env, uvCacheDir) {
-  const env = {
+function getProtectedUvEnv(baseEnv = process.env) {
+  return {
     ...baseEnv,
     UV_PYTHON_DOWNLOADS: UV_PYTHON_DOWNLOADS_MODE
   };
-  if (uvCacheDir) {
-    env.UV_CACHE_DIR = uvCacheDir;
-  }
-  return env;
 }
 var UV_BUNDLE_DIR = "_uv";
 async function getUvBinaryForBundling(pythonPath) {
@@ -3212,9 +3202,9 @@ function useVirtualEnv(workPath, env, systemPython) {
   }
   return { pythonCmd };
 }
-function createVenvEnv(venvPath, baseEnv = process.env, uvCacheDir) {
+function createVenvEnv(venvPath, baseEnv = process.env) {
   const env = {
-    ...getProtectedUvEnv(baseEnv, uvCacheDir),
+    ...getProtectedUvEnv(baseEnv),
     VIRTUAL_ENV: venvPath
   };
   const binDir = getVenvBinDir(venvPath);
@@ -3226,7 +3216,6 @@ async function ensureVenv({
   pythonPath,
   venvPath,
   uvPath,
-  uvCacheDir,
   quiet
 }) {
   const marker = (0, import_path3.join)(venvPath, "pyvenv.cfg");
@@ -3240,9 +3229,7 @@ async function ensureVenv({
     console.log(`Creating virtual environment at "${venvPath}"...`);
   }
   if (uvPath) {
-    await (0, import_execa2.default)(uvPath, ["venv", venvPath], {
-      env: getProtectedUvEnv(process.env, uvCacheDir)
-    });
+    await (0, import_execa2.default)(uvPath, ["venv", venvPath]);
   } else {
     await (0, import_execa2.default)(pythonPath, ["-m", "venv", venvPath]);
   }
@@ -3749,7 +3736,7 @@ async function pipInstall(pipPath, uvPath, workPath, args, targetDir) {
     try {
       await (0, import_execa3.default)(uvPath, uvArgs, {
         cwd: workPath,
-        env: getProtectedUvEnv(process.env, getUvCacheDir(workPath))
+        env: getProtectedUvEnv()
       });
       return;
     } catch (err) {
@@ -3831,7 +3818,7 @@ var import_build_utils5 = require("@vercel/build-utils");
 var import_python_analysis3 = require("@vercel/python-analysis");
 var readFile = (0, import_util.promisify)(import_fs4.default.readFile);
 var LAMBDA_SIZE_THRESHOLD_BYTES = 249 * 1024 * 1024;
-var LAMBDA_PACKING_TARGET_BYTES = 245 * 1024 * 1024;
+var LAMBDA_PACKING_TARGET_BYTES = 240 * 1024 * 1024;
 var LAMBDA_EPHEMERAL_STORAGE_BYTES = 500 * 1024 * 1024;
 var PythonDependencyExternalizer = class {
   constructor(options) {
@@ -4403,7 +4390,7 @@ function createLogListener(callback, stream) {
   };
 }
 function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 async function checkForPort(port, timeout) {
   const start = Date.now();
@@ -4533,7 +4520,7 @@ async function runSync({
       (0, import_build_utils8.debug)(`Unknown manifest type: ${manifestType}`);
       return;
   }
-  await new Promise((resolve2, reject) => {
+  await new Promise((resolve3, reject) => {
     (0, import_build_utils8.debug)(`Running "${spawnCmd} ${spawnArgs.join(" ")}" in ${projectDir}...`);
     const child = (0, import_child_process2.spawn)(spawnCmd, spawnArgs, {
       cwd: projectDir,
@@ -4557,7 +4544,7 @@ async function runSync({
     child.on("error", reject);
     child.on("exit", (code, signal) => {
       if (code === 0) {
-        resolve2();
+        resolve3();
       } else {
         reject(
           new Error(
@@ -4605,7 +4592,7 @@ async function installVercelRuntime({
   );
   const pip = uvPath ? { cmd: uvPath, prefix: ["pip", "install"] } : { cmd: pythonBin, prefix: ["-m", "pip", "install"] };
   const spawnArgs = [...pip.prefix, "--target", targetDir, runtimeDep];
-  await new Promise((resolve2, reject) => {
+  await new Promise((resolve3, reject) => {
     const child = (0, import_child_process2.spawn)(pip.cmd, spawnArgs, {
       cwd: workPath,
       env: getProtectedUvEnv(env),
@@ -4628,7 +4615,7 @@ async function installVercelRuntime({
     child.on("error", reject);
     child.on("exit", (code, signal) => {
       if (code === 0) {
-        resolve2();
+        resolve3();
       } else {
         reject(
           new Error(
@@ -4716,12 +4703,7 @@ async function getMultiServicePythonRunner(workPath, env, systemPython, uvPath)
     return { command: pythonCmd, args: [] };
   }
   const venvPath = (0, import_path8.join)(workPath, ".venv");
-  await ensureVenv({
-    pythonPath: systemPython,
-    venvPath,
-    uvPath,
-    quiet: true
-  });
+  await ensureVenv({ pythonPath: systemPython, venvPath, uvPath, quiet: true });
   (0, import_build_utils8.debug)(`Created virtualenv at ${venvPath} for multi-service dev`);
   const pythonBin = getVenvPythonBin(venvPath);
   const binDir = getVenvBinDir(venvPath);
@@ -4799,8 +4781,8 @@ var startDevServer = async (opts) => {
   let resolveChildReady;
   let rejectChildReady;
   const childReady = new Promise(
-    (resolve2, reject) => {
-      resolveChildReady = resolve2;
+    (resolve3, reject) => {
+      resolveChildReady = resolve3;
       rejectChildReady = reject;
     }
   );
@@ -5421,24 +5403,109 @@ async function runQuirks(ctx) {
 }
 
 // src/django.ts
-var import_fs9 = require("fs");
+var import_fs9 = __toESM(require("fs"));
 var import_path11 = require("path");
 var import_execa5 = __toESM(require_execa());
 var import_build_utils12 = require("@vercel/build-utils");
 var scriptPath = (0, import_path11.join)(__dirname, "..", "templates", "vc_django_settings.py");
-var script = (0, import_fs9.readFileSync)(scriptPath, "utf-8");
+var script = import_fs9.default.readFileSync(scriptPath, "utf-8");
 async function getDjangoSettings(projectDir, env) {
   try {
     const { stdout } = await (0, import_execa5.default)("python", ["-c", script], {
       env,
       cwd: projectDir
     });
-    return JSON.parse(stdout);
+    const parsed = JSON.parse(stdout);
+    if (!parsed)
+      return null;
+    return {
+      settingsModule: parsed.settings_module,
+      djangoSettings: parsed.django_settings
+    };
   } catch (err) {
     (0, import_build_utils12.debug)(`Django hook: failed to discover settings from manage.py: ${err}`);
     return null;
   }
 }
+async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir, settingsModule, djangoSettings) {
+  const pythonPath = getVenvPythonBin(venvPath);
+  const storages = djangoSettings["STORAGES"];
+  const storageBackend = storages?.staticfiles?.BACKEND ?? djangoSettings["STATICFILES_STORAGE"] ?? "django.contrib.staticfiles.storage.StaticFilesStorage";
+  const staticUrl = djangoSettings["STATIC_URL"] ?? "/static/";
+  const staticRoot = djangoSettings["STATIC_ROOT"] != null ? String(djangoSettings["STATIC_ROOT"]) : null;
+  const whitenoiseUseFinders = djangoSettings["WHITENOISE_USE_FINDERS"] === true;
+  const installedApps = djangoSettings["INSTALLED_APPS"] ?? [];
+  const staticfilesDirs = djangoSettings["STATICFILES_DIRS"] ?? [];
+  const staticSourceDirs = [
+    ...installedApps.map((app) => (0, import_path11.join)(workPath, ...app.split("."), "static")),
+    // TODO: Deal with optional prefixes in STATICFILES_DIRS.
+    ...staticfilesDirs.map((d) => Array.isArray(d) ? d[1] : d)
+  ].filter((d) => import_fs9.default.existsSync(d));
+  if (storageBackend.startsWith("storages.backends.")) {
+    console.log(
+      "django-storages detected \u2014 running collectstatic with original settings"
+    );
+    await (0, import_execa5.default)(pythonPath, ["manage.py", "collectstatic", "--noinput"], {
+      env: { ...env, DJANGO_SETTINGS_MODULE: settingsModule },
+      cwd: workPath
+    });
+    return {
+      staticSourceDirs,
+      staticRoot: staticRoot ? (0, import_path11.resolve)(workPath, staticRoot) : null,
+      manifestRelPath: null
+    };
+  }
+  if (!staticRoot && !whitenoiseUseFinders) {
+    console.log(
+      "No collectstatic strategy configured \u2014 skipping collectstatic"
+    );
+    return null;
+  }
+  const staticUrlPath = staticUrl.replace(/^\/|\/$/g, "") || "static";
+  const staticOutputDir = (0, import_path11.join)(outputStaticDir, staticUrlPath);
+  await import_fs9.default.promises.mkdir(staticOutputDir, { recursive: true });
+  const shimPath = (0, import_path11.join)(workPath, "_vercel_collectstatic_settings.py");
+  const shimLines = [
+    `from ${settingsModule} import *`,
+    `STATIC_ROOT = ${JSON.stringify(staticOutputDir)}`
+  ];
+  if (whitenoiseUseFinders) {
+    shimLines.push(`WHITENOISE_USE_FINDERS = False`);
+  }
+  await import_fs9.default.promises.writeFile(shimPath, shimLines.join("\n") + "\n");
+  try {
+    console.log("Running collectstatic...");
+    await (0, import_execa5.default)(pythonPath, ["manage.py", "collectstatic", "--noinput"], {
+      env: {
+        ...env,
+        DJANGO_SETTINGS_MODULE: "_vercel_collectstatic_settings"
+      },
+      cwd: workPath
+    });
+  } finally {
+    await import_fs9.default.promises.unlink(shimPath).catch(() => {
+    });
+  }
+  const MANIFEST_STORAGE_BACKENDS = [
+    "django.contrib.staticfiles.storage.ManifestStaticFilesStorage",
+    "whitenoise.storage.CompressedManifestStaticFilesStorage"
+  ];
+  let manifestRelPath = null;
+  if (MANIFEST_STORAGE_BACKENDS.includes(storageBackend) && staticRoot) {
+    const manifestSrc = (0, import_path11.join)(staticOutputDir, "staticfiles.json");
+    const resolvedStaticRoot = (0, import_path11.resolve)(workPath, staticRoot);
+    const manifestDest = (0, import_path11.join)(resolvedStaticRoot, "staticfiles.json");
+    await import_fs9.default.promises.mkdir(resolvedStaticRoot, { recursive: true });
+    await import_fs9.default.promises.copyFile(manifestSrc, manifestDest);
+    manifestRelPath = (0, import_path11.relative)(workPath, manifestDest);
+    (0, import_build_utils12.debug)(`Copied staticfiles.json to ${manifestDest} for Lambda bundle`);
+  }
+  return {
+    staticSourceDirs,
+    staticRoot: staticRoot ? (0, import_path11.resolve)(workPath, staticRoot) : null,
+    manifestRelPath
+  };
+}
 
 // src/index.ts
 var import_python_analysis7 = require("@vercel/python-analysis");
@@ -5449,30 +5516,47 @@ async function runFrameworkHook(framework, ctx) {
   return hook?.(ctx);
 }
 var frameworkHooks = {
-  django: async ({ pythonEnv, projectDir, detected }) => {
+  django: async ({
+    pythonEnv,
+    projectDir,
+    workPath,
+    venvPath,
+    detected
+  }) => {
     if (detected?.baseDir === void 0) {
       (0, import_build_utils13.debug)("Django hook: no manage.py detected, skipping");
       return;
     }
-    const settings = await getDjangoSettings(projectDir, pythonEnv);
-    (0, import_build_utils13.debug)(`Django settings: ${JSON.stringify(settings)}`);
-    if (!settings)
+    const settingsResult = await getDjangoSettings(projectDir, pythonEnv);
+    (0, import_build_utils13.debug)(`Django settings: ${JSON.stringify(settingsResult)}`);
+    if (!settingsResult)
       return;
+    const { djangoSettings, settingsModule } = settingsResult;
+    let entrypoint;
     const baseDir = detected?.baseDir ?? "";
-    const asgiApp = settings["ASGI_APPLICATION"];
+    const asgiApp = djangoSettings["ASGI_APPLICATION"];
     if (typeof asgiApp === "string") {
       const rel = `${asgiApp.split(".").slice(0, -1).join("/")}.py`;
-      const entrypoint = baseDir ? `${baseDir}/${rel}` : rel;
+      entrypoint = baseDir ? `${baseDir}/${rel}` : rel;
       (0, import_build_utils13.debug)(`Django hook: ASGI entrypoint: ${entrypoint}`);
-      return { entrypoint };
-    }
-    const wsgiApp = settings["WSGI_APPLICATION"];
-    if (typeof wsgiApp === "string") {
-      const rel = `${wsgiApp.split(".").slice(0, -1).join("/")}.py`;
-      const entrypoint = baseDir ? `${baseDir}/${rel}` : rel;
-      (0, import_build_utils13.debug)(`Django hook: WSGI entrypoint: ${entrypoint}`);
-      return { entrypoint };
+    } else {
+      const wsgiApp = djangoSettings["WSGI_APPLICATION"];
+      if (typeof wsgiApp === "string") {
+        const rel = `${wsgiApp.split(".").slice(0, -1).join("/")}.py`;
+        entrypoint = baseDir ? `${baseDir}/${rel}` : rel;
+        (0, import_build_utils13.debug)(`Django hook: WSGI entrypoint: ${entrypoint}`);
+      }
     }
+    const outputStaticDir = (0, import_path12.join)(workPath, ".vercel", "output", "static");
+    const djangoStatic = await runDjangoCollectStatic(
+      venvPath,
+      workPath,
+      pythonEnv,
+      outputStaticDir,
+      settingsModule,
+      djangoSettings
+    );
+    return { entrypoint, djangoStatic };
   }
 };
 async function downloadFilesInWorkPath({
@@ -5584,12 +5668,10 @@ var build = async ({
   }
   fsFiles = await (0, import_build_utils13.glob)("**", workPath);
   const venvPath = (0, import_path12.join)(workPath, ".vercel", "python", ".venv");
-  const uvCacheDir = getUvCacheDir(workPath);
   await builderSpan.child("vc.builder.python.venv").trace(async () => {
     await ensureVenv({
       pythonPath: pythonVersion.pythonPath,
-      venvPath,
-      uvCacheDir
+      venvPath
     });
   });
   if ((0, import_build_utils13.isPythonFramework)(framework)) {
@@ -5618,14 +5700,14 @@ var build = async ({
     }
   }
   const baseEnv = spawnEnv || process.env;
-  const pythonEnv = createVenvEnv(venvPath, baseEnv, uvCacheDir);
+  const pythonEnv = createVenvEnv(venvPath, baseEnv);
   pythonEnv.VERCEL_PYTHON_VENV_PATH = venvPath;
   let assumeDepsInstalled = false;
   let uv;
   try {
     const uvPath = await getUvBinaryOrInstall(pythonVersion.pythonPath);
     console.log(`Using uv at "${uvPath}"`);
-    uv = new UvRunner(uvPath, uvCacheDir);
+    uv = new UvRunner(uvPath);
   } catch (err) {
     console.log("Failed to install or locate uv");
     throw new Error(
@@ -5722,6 +5804,8 @@ var build = async ({
   const hookResult = await runFrameworkHook(framework, {
     pythonEnv,
     projectDir: (0, import_path12.join)(workPath, entryDirectory),
+    workPath,
+    venvPath,
     entrypoint,
     detected
   });
@@ -5732,6 +5816,7 @@ var build = async ({
   if (entrypointNotFound) {
     throw entrypointNotFound;
   }
+  const djangoStatic = hookResult?.djangoStatic ?? null;
   const runtimeDep = baseEnv.VERCEL_RUNTIME_PYTHON || `vercel-runtime==${VERCEL_RUNTIME_VERSION}`;
   (0, import_build_utils13.debug)(`Installing ${runtimeDep}`);
   await uv.pip({
@@ -5828,6 +5913,18 @@ from vercel_runtime.vc_init import vc_handler
     "**/yarn.lock",
     "**/package-lock.json"
   ];
+  if (djangoStatic) {
+    const dirsToExclude = [
+      ...djangoStatic.staticSourceDirs,
+      ...djangoStatic.staticRoot ? [djangoStatic.staticRoot] : []
+    ];
+    for (const absDir of dirsToExclude) {
+      const rel = (0, import_path12.relative)(workPath, absDir);
+      if (!rel.startsWith("..")) {
+        predefinedExcludes.push(`${rel}/**`);
+      }
+    }
+  }
   const lambdaEnv = {};
   lambdaEnv.PYTHONPATH = vendorDir;
   Object.assign(lambdaEnv, quirksResult.env);
@@ -5836,6 +5933,11 @@ from vercel_runtime.vc_init import vc_handler
     ignore: config && typeof config.excludeFiles === "string" ? [...predefinedExcludes, config.excludeFiles] : predefinedExcludes
   };
   const files = await (0, import_build_utils13.glob)("**", globOptions);
+  if (djangoStatic?.manifestRelPath) {
+    files[djangoStatic.manifestRelPath] = new import_build_utils13.FileFsRef({
+      fsPath: (0, import_path12.join)(workPath, djangoStatic.manifestRelPath)
+    });
+  }
   const depExternalizer = new PythonDependencyExternalizer({
     venvPath,
     vendorDir,
@@ -5882,41 +5984,6 @@ from vercel_runtime.vc_init import vc_handler
   });
   return { output };
 };
-async function readBuildOutputV3Config(workPath) {
-  try {
-    const configPath = (0, import_path12.join)(workPath, ".vercel", "output", "config.json");
-    return JSON.parse(await import_fs10.default.promises.readFile(configPath, "utf8"));
-  } catch (err) {
-    if (err.code !== "ENOENT") {
-      throw err;
-    }
-  }
-  return void 0;
-}
-var prepareCache = async ({
-  repoRootPath,
-  workPath
-}) => {
-  const cacheFiles = {};
-  const root = repoRootPath || workPath;
-  const ignore = ["**/*.pyc", "**/__pycache__/**"];
-  const configV3 = await readBuildOutputV3Config(workPath);
-  if (configV3?.cache && Array.isArray(configV3.cache)) {
-    for (const cacheGlob of configV3.cache) {
-      Object.assign(cacheFiles, await (0, import_build_utils13.glob)(cacheGlob, workPath));
-    }
-    return cacheFiles;
-  }
-  Object.assign(
-    cacheFiles,
-    await (0, import_build_utils13.glob)("**/.vercel/python/.venv/**", { cwd: root, ignore })
-  );
-  Object.assign(
-    cacheFiles,
-    await (0, import_build_utils13.glob)("**/.vercel/python/cache/uv/**", { cwd: root, ignore })
-  );
-  return cacheFiles;
-};
 var shouldServe = (opts) => {
   const framework = opts.config.framework;
   if ((0, import_build_utils13.isPythonFramework)(framework)) {
@@ -5954,7 +6021,6 @@ function hasProp(obj, key) {
   downloadFilesInWorkPath,
   installRequirement,
   installRequirementsFile,
-  prepareCache,
   runFrameworkHook,
   shouldServe,
   startDevServer,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/python",
-  "version": "6.22.0",
+  "version": "6.23.0",
   "main": "./dist/index.js",
   "license": "Apache-2.0",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/python",
@@ -35,9 +35,9 @@
     "which": "3.0.0",
     "get-port": "5.1.1",
     "is-port-reachable": "3.1.0",
-    "@vercel/python-runtime": "0.7.0",
     "@vercel/build-utils": "13.8.0",
-    "@vercel/error-utils": "2.0.3"
+    "@vercel/error-utils": "2.0.3",
+    "@vercel/python-runtime": "0.7.0"
   },
   "scripts": {
     "build": "node ../../utils/build-builder.mjs",

package/templates/vc_django_settings.py

@@ -33,4 +33,12 @@ else:
 
     mod = importlib.import_module(settings_module)
     settings = {k: getattr(mod, k) for k in dir(mod) if k.isupper()}
-    print(json.dumps(settings, default=str))
+    print(
+        json.dumps(
+            {
+                "settings_module": settings_module,
+                "django_settings": settings,
+            },
+            default=str,
+        )
+    )