@vercel/python 6.40.0 → 6.42.0

package/dist/index.js

@@ -3213,6 +3213,7 @@ var src_exports = {};
 __export(src_exports, {
   build: () => build,
   defaultShouldServe: () => defaultShouldServe,
+  detectEntrypoint: () => detectEntrypoint,
   diagnostics: () => diagnostics,
   downloadFilesInWorkPath: () => downloadFilesInWorkPath,
   installRequirement: () => installRequirement,
@@ -3231,7 +3232,7 @@ var import_path13 = require("path");
 
 // src/package-versions.ts
 var VERCEL_RUNTIME_VERSION = "0.13.2";
-var VERCEL_WORKERS_VERSION = "0.0.22";
+var VERCEL_WORKERS_VERSION = "0.0.23";
 
 // src/index.ts
 var import_build_utils16 = require("@vercel/build-utils");
@@ -5215,166 +5216,17 @@ async function generateProjectManifest({
 var diagnostics = (0, import_build_utils6.createDiagnostics)("python");
 
 // src/crons.ts
-var import_fs7 = __toESM(require("fs"));
-var import_path7 = require("path");
+var import_fs8 = __toESM(require("fs"));
+var import_path8 = require("path");
 var import_execa4 = __toESM(require_execa());
-var import_build_utils7 = require("@vercel/build-utils");
-var DYNAMIC_SCHEDULE = "<dynamic>";
-function entrypointToModule(entrypoint) {
-  return entrypoint.replace(/\\/g, "/").replace(/\.py$/i, "").replace(/\//g, ".");
-}
-var scriptPath = (0, import_path7.join)(__dirname, "..", "templates", "vc_cron_detect.py");
-var script = import_fs7.default.readFileSync(scriptPath, "utf-8");
-function buildCronRouteTable(crons) {
-  const table = {};
-  for (const cron of crons) {
-    table[cron.path] = cron.resolvedHandler;
-  }
-  return table;
-}
-async function getServiceCrons(opts) {
-  const { service, entrypoint, rawEntrypoint, handlerFunction } = opts;
-  const isScheduledService = !!service && (0, import_build_utils7.isScheduleTriggeredService)(service);
-  if (!isScheduledService || !service.name || typeof service.schedule !== "string" && !Array.isArray(service.schedule)) {
-    return void 0;
-  }
-  const cronEntrypoint = entrypoint || rawEntrypoint;
-  if (!cronEntrypoint) {
-    throw new import_build_utils7.NowBuildError({
-      code: "PYTHON_CRON_NO_ENTRYPOINT",
-      message: "Cron service is missing an entrypoint."
-    });
-  }
-  if (service.schedule === DYNAMIC_SCHEDULE) {
-    return getServiceCronsDynamic({
-      serviceName: service.name,
-      cronEntrypoint,
-      handlerFunction,
-      pythonBin: opts.pythonBin,
-      env: opts.env,
-      workPath: opts.workPath
-    });
-  }
-  const cronPath = (0, import_build_utils7.getInternalServiceCronPath)(
-    service.name,
-    cronEntrypoint,
-    handlerFunction || "cron"
-  );
-  const moduleName = entrypointToModule(cronEntrypoint);
-  const resolvedHandler = handlerFunction ? `${moduleName}:${handlerFunction}` : moduleName;
-  const schedules = Array.isArray(service.schedule) ? service.schedule : [service.schedule];
-  return schedules.map((schedule) => ({
-    path: cronPath,
-    schedule,
-    resolvedHandler
-  }));
-}
-async function getServiceCronsDynamic(opts) {
-  const {
-    serviceName,
-    cronEntrypoint,
-    handlerFunction,
-    pythonBin,
-    env,
-    workPath
-  } = opts;
-  if (!handlerFunction) {
-    throw new import_build_utils7.NowBuildError({
-      code: "PYTHON_DYNAMIC_CRON_NO_HANDLER",
-      message: 'Dynamic cron detection requires a "module:object" entrypoint where the object has a get_crons() method.'
-    });
-  }
-  const moduleName = entrypointToModule(cronEntrypoint);
-  const entries = await detectDynamicCrons({
-    pythonBin,
-    env,
-    workPath,
-    moduleName,
-    attrName: handlerFunction
-  });
-  console.log(
-    `Detected ${entries.length} cron entry(s): ${entries.map((e) => `${e.module_function} (${e.schedule})`).join(", ")}`
-  );
-  if (entries.length === 0) {
-    throw new import_build_utils7.NowBuildError({
-      code: "PYTHON_DYNAMIC_CRON_EMPTY",
-      message: `Dynamic cron detection returned no entries. "${moduleName}.${handlerFunction}.get_crons()" returned an empty iterable.`
-    });
-  }
-  return entries.map((entry) => {
-    const cronPath = moduleColonFuncToCronPath(
-      serviceName,
-      entry.module_function
-    );
-    return {
-      path: cronPath,
-      schedule: entry.schedule,
-      resolvedHandler: entry.module_function
-    };
-  });
-}
-async function detectDynamicCrons(opts) {
-  const { pythonBin, env, workPath, moduleName, attrName } = opts;
-  let stdout;
-  try {
-    const result = await (0, import_execa4.default)(
-      pythonBin,
-      ["-c", script, moduleName, attrName],
-      { env, cwd: workPath }
-    );
-    stdout = result.stdout;
-  } catch (err) {
-    let detail = err?.stderr || err?.message || String(err);
-    try {
-      const parsed2 = JSON.parse(err?.stdout);
-      if (parsed2.error)
-        detail = parsed2.error;
-    } catch {
-    }
-    throw new import_build_utils7.NowBuildError({
-      code: "PYTHON_DYNAMIC_CRON_DETECTION_FAILED",
-      message: `Failed to detect dynamic cron entries: ${detail}`
-    });
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(stdout);
-  } catch {
-    throw new import_build_utils7.NowBuildError({
-      code: "PYTHON_DYNAMIC_CRON_DETECTION_FAILED",
-      message: `Dynamic cron detection returned invalid JSON: ${stdout}`
-    });
-  }
-  return parsed.entries || [];
-}
-function moduleColonFuncToCronPath(serviceName, moduleFunction) {
-  const colonIdx = moduleFunction.indexOf(":");
-  if (colonIdx === -1) {
-    throw new import_build_utils7.NowBuildError({
-      code: "PYTHON_DYNAMIC_CRON_INVALID_FORMAT",
-      message: `Dynamic cron entry must use "module:function" format, got: "${moduleFunction}"`
-    });
-  }
-  const modulePart = moduleFunction.slice(0, colonIdx);
-  const funcPart = moduleFunction.slice(colonIdx + 1);
-  const entrypointPath = modulePart.replace(/\./g, "/");
-  return (0, import_build_utils7.getInternalServiceCronPath)(serviceName, entrypointPath, funcPart);
-}
-
-// src/start-dev-server.ts
-var import_child_process2 = require("child_process");
-var import_fs9 = require("fs");
-var import_path9 = require("path");
-var import_build_utils11 = require("@vercel/build-utils");
-var import_get_port = __toESM(require_get_port());
-var import_is_port_reachable = __toESM(require_is_port_reachable());
+var import_build_utils10 = require("@vercel/build-utils");
 
 // src/entrypoint.ts
-var import_fs8 = __toESM(require("fs"));
-var import_path8 = require("path");
+var import_fs7 = __toESM(require("fs"));
+var import_path7 = require("path");
+var import_build_utils7 = require("@vercel/build-utils");
 var import_build_utils8 = require("@vercel/build-utils");
 var import_build_utils9 = require("@vercel/build-utils");
-var import_build_utils10 = require("@vercel/build-utils");
 var import_python_analysis5 = require("@vercel/python-analysis");
 var PYTHON_ENTRYPOINT_FILENAMES = [
   "app",
@@ -5389,16 +5241,17 @@ var PYTHON_CANDIDATE_ENTRYPOINTS = getCandidateEntrypointsInDirs(
   PYTHON_ENTRYPOINT_DIRS
 );
 var PYTHON_ENTRYPOINT_DOCS_URL = "https://vercel.com/docs/functions/runtimes/python#python-entrypoints";
+var SKIP_DIRS = /* @__PURE__ */ new Set(["__pycache__", "node_modules"]);
 function getCandidateEntrypointsInDirs(dirs) {
   return dirs.flatMap(
     (dir) => PYTHON_ENTRYPOINT_FILENAMES.map(
-      (filename) => import_path8.posix.join(dir, `${filename}.py`)
+      (filename) => import_path7.posix.join(dir, `${filename}.py`)
     )
   );
 }
 async function fileExists(filePath) {
   try {
-    const stat = await import_fs8.default.promises.stat(filePath);
+    const stat = await import_fs7.default.promises.stat(filePath);
     return stat.isFile();
   } catch {
     return false;
@@ -5449,34 +5302,67 @@ function getMissingExportMessage(framework, entrypoints) {
       return entrypoints.length === 1 ? `Found ${fileList} but it does not export a top-level "app", "application", or "handler" variable.` : `Found ${fileList} but none export a top-level "app", "application", or "handler" variable.`;
   }
 }
+function entrypointToModule(entrypoint) {
+  return entrypoint.replace(/\\/g, "/").replace(/\.py$/i, "").replace(/\//g, ".");
+}
 async function checkEntrypoint(workPath, relPath) {
-  const absPath = (0, import_path8.join)(workPath, relPath);
+  const absPath = (0, import_path7.join)(workPath, relPath);
   if (!await fileExists(absPath))
     return null;
-  const content = await import_fs8.default.promises.readFile(absPath, "utf-8");
+  const content = await import_fs7.default.promises.readFile(absPath, "utf-8");
   return (0, import_python_analysis5.findAppOrHandler)(content);
 }
-async function findOtherPyFiles(workPath, dirs, candidateSet) {
+async function findPythonFilesRecursive(dir, rootDir) {
   const results = [];
-  for (const dir of dirs) {
-    const dirPath = (0, import_path8.join)(workPath, dir);
+  let entries;
+  try {
+    entries = await import_fs7.default.promises.readdir(dir, { withFileTypes: true });
+  } catch {
+    return results;
+  }
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") || SKIP_DIRS.has(entry.name))
+      continue;
+    const fullPath = (0, import_path7.join)(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...await findPythonFilesRecursive(fullPath, rootDir));
+    } else if (entry.isFile() && entry.name.endsWith(".py")) {
+      results.push((0, import_path7.relative)(rootDir, fullPath).replace(/\\/g, "/"));
+    }
+  }
+  return results;
+}
+async function findEntrypointCandidates(workPath) {
+  const pyFiles = await findPythonFilesRecursive(workPath, workPath);
+  const candidates = [];
+  for (const relPath of pyFiles) {
     try {
-      const entries = await import_fs8.default.promises.readdir(dirPath);
-      for (const entry of entries) {
-        if (!entry.endsWith(".py"))
-          continue;
-        const relPath = dir ? import_path8.posix.join(dir, entry) : entry;
-        if (candidateSet.has(relPath))
-          continue;
-        const stat = await import_fs8.default.promises.stat((0, import_path8.join)(dirPath, entry));
-        if (stat.isFile()) {
-          results.push(relPath);
-        }
+      const content = await import_fs7.default.promises.readFile(
+        (0, import_path7.join)(workPath, relPath),
+        "utf-8"
+      );
+      const varName = await (0, import_python_analysis5.findAppOrHandler)(content);
+      if (varName) {
+        candidates.push({ entrypoint: relPath, variableName: varName });
       }
     } catch {
     }
   }
-  return results;
+  return candidates;
+}
+function renderCandidateSuggestion(candidates) {
+  const lines = candidates.map(
+    (c) => `  ${c.entrypoint} (variable: ${c.variableName})`
+  );
+  const suggested = candidates[0];
+  const moduleAttr = `${entrypointToModule(suggested.entrypoint)}:${suggested.variableName}`;
+  return `but found potential entrypoints:
+${lines.join("\n")}
+
+Add this to your pyproject.toml:
+
+[tool.vercel]
+entrypoint = "${moduleAttr}"`;
 }
 async function resolveModuleAttrEntrypoint(workPath, value) {
   const match = value.match(/([A-Za-z_][\w.]*)\s*:\s*([A-Za-z_][\w]*)/);
@@ -5487,14 +5373,14 @@ async function resolveModuleAttrEntrypoint(workPath, value) {
   const relPath = modulePath.replace(/\./g, "/");
   const candidates = [`${relPath}.py`, `${relPath}/__init__.py`];
   for (const candidate of candidates) {
-    if (await fileExists((0, import_path8.join)(workPath, candidate))) {
+    if (await fileExists((0, import_path7.join)(workPath, candidate))) {
       return { entrypoint: candidate, variableName };
     }
   }
   return null;
 }
 async function getVercelToolsEntrypoint(workPath) {
-  const pyprojectData = await (0, import_build_utils10.readConfigFile)((0, import_path8.join)(workPath, "pyproject.toml"));
+  const pyprojectData = await (0, import_build_utils9.readConfigFile)((0, import_path7.join)(workPath, "pyproject.toml"));
   if (!pyprojectData)
     return null;
   const vercelEntrypoint = pyprojectData.tool?.vercel?.entrypoint;
@@ -5503,7 +5389,7 @@ async function getVercelToolsEntrypoint(workPath) {
   return resolveModuleAttrEntrypoint(workPath, vercelEntrypoint);
 }
 async function getPyprojectEntrypointWithDiagnostics(workPath) {
-  const pyprojectData = await (0, import_build_utils10.readConfigFile)((0, import_path8.join)(workPath, "pyproject.toml"));
+  const pyprojectData = await (0, import_build_utils9.readConfigFile)((0, import_path7.join)(workPath, "pyproject.toml"));
   if (!pyprojectData)
     return { entrypoint: null };
   const scripts = pyprojectData.project?.scripts;
@@ -5518,7 +5404,7 @@ async function getPyprojectEntrypointWithDiagnostics(workPath) {
   const relPath = modulePath.replace(/\./g, "/");
   const candidates = [`${relPath}.py`, `${relPath}/__init__.py`];
   for (const candidate of candidates) {
-    if (await fileExists((0, import_path8.join)(workPath, candidate))) {
+    if (await fileExists((0, import_path7.join)(workPath, candidate))) {
       return { entrypoint: { entrypoint: candidate, variableName } };
     }
   }
@@ -5527,13 +5413,13 @@ async function getPyprojectEntrypointWithDiagnostics(workPath) {
 async function findValidEntrypoint(workPath, candidates) {
   const existingWithoutEntrypoint = [];
   for (const candidate of candidates) {
-    const absPath = (0, import_path8.join)(workPath, candidate);
+    const absPath = (0, import_path7.join)(workPath, candidate);
     if (!await fileExists(absPath))
       continue;
-    const content = await import_fs8.default.promises.readFile(absPath, "utf-8");
+    const content = await import_fs7.default.promises.readFile(absPath, "utf-8");
     const varName = await (0, import_python_analysis5.findAppOrHandler)(content);
     if (varName) {
-      (0, import_build_utils9.debug)(`Detected Python entrypoint: ${candidate} (variable: ${varName})`);
+      (0, import_build_utils8.debug)(`Detected Python entrypoint: ${candidate} (variable: ${varName})`);
       return {
         entrypoint: { entrypoint: candidate, variableName: varName },
         existingWithoutEntrypoint
@@ -5544,12 +5430,12 @@ async function findValidEntrypoint(workPath, candidates) {
   return { entrypoint: null, existingWithoutEntrypoint };
 }
 async function checkDjangoManage(workPath) {
-  const managePath = (0, import_path8.join)(workPath, "manage.py");
+  const managePath = (0, import_path7.join)(workPath, "manage.py");
   try {
-    const content = await import_fs8.default.promises.readFile(managePath, "utf-8");
+    const content = await import_fs7.default.promises.readFile(managePath, "utf-8");
     if (!content.includes("DJANGO_SETTINGS_MODULE"))
       return false;
-    (0, import_build_utils9.debug)(`Found Django manage.py with DJANGO_SETTINGS_MODULE at ${workPath}`);
+    (0, import_build_utils8.debug)(`Found Django manage.py with DJANGO_SETTINGS_MODULE at ${workPath}`);
     return true;
   } catch {
     return false;
@@ -5557,7 +5443,7 @@ async function checkDjangoManage(workPath) {
 }
 async function getSubdirectories(workPath) {
   try {
-    const entries = await import_fs8.default.promises.readdir(workPath, {
+    const entries = await import_fs7.default.promises.readdir(workPath, {
       withFileTypes: true
     });
     return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name).sort();
@@ -5570,23 +5456,39 @@ function makeDiagnosticError(framework, diagnostics2) {
   const link = getFrameworkEntrypointDocsUrl(framework);
   const action = "Learn More";
   const displayName = getFrameworkDisplayName(framework);
+  const elsewhere = diagnostics2.validCandidatesElsewhere ?? [];
+  const suggestion = elsewhere.length > 0 ? renderCandidateSuggestion(elsewhere) : null;
   let message;
   if (diagnostics2.existingWithoutEntrypoint.length > 0) {
     message = getMissingExportMessage(
       framework,
       diagnostics2.existingWithoutEntrypoint
     );
+    if (suggestion)
+      message += `
+
+${suggestion}`;
+  } else if (diagnostics2.djangoManageBaseDir !== void 0) {
+    const where = diagnostics2.djangoManageBaseDir || ".";
+    message = `Found Django manage.py in "${where}" but could not resolve the application entrypoint. Ensure WSGI_APPLICATION or ASGI_APPLICATION is set in your Django settings.`;
+    if (suggestion)
+      message += `
+
+${suggestion}`;
   } else if (diagnostics2.pyprojectAppScript && diagnostics2.pyprojectCheckedPaths?.length) {
     const checked = diagnostics2.pyprojectCheckedPaths.join(" or ");
     message = `pyproject.toml [project.scripts] defines app = "${diagnostics2.pyprojectAppScript}" but ${checked} was not found.`;
-  } else if (diagnostics2.otherPyFiles.length > 0) {
-    const fileList = diagnostics2.otherPyFiles.slice(0, 5).join(", ");
-    message = `No ${displayName} entrypoint found in standard locations. Found Python files: ${fileList}. Rename one to app.py or set "tool.vercel.entrypoint" in pyproject.toml.`;
+    if (suggestion)
+      message += `
+
+${suggestion}`;
+  } else if (suggestion) {
+    message = `No ${displayName} entrypoint found in default locations, ${suggestion}`;
   } else {
     const searchedList = PYTHON_CANDIDATE_ENTRYPOINTS.join(", ");
     message = `No ${displayName} entrypoint found. Set "tool.vercel.entrypoint" in pyproject.toml or define an entrypoint in one of: ${searchedList}.`;
   }
-  return new import_build_utils8.NowBuildError({ code, message, link, action });
+  return new import_build_utils7.NowBuildError({ code, message, link, action });
 }
 async function detectGenericPythonEntrypoint(workPath) {
   try {
@@ -5599,7 +5501,7 @@ async function detectGenericPythonEntrypoint(workPath) {
       findDiagnostics: result
     };
   } catch {
-    (0, import_build_utils9.debug)("Failed to discover Python entrypoint");
+    (0, import_build_utils8.debug)("Failed to discover Python entrypoint");
     return {
       detected: null,
       findDiagnostics: { entrypoint: null, existingWithoutEntrypoint: [] }
@@ -5612,20 +5514,18 @@ async function detectDjangoPythonEntrypoint(workPath) {
     findDiagnostics: {
       entrypoint: null,
       existingWithoutEntrypoint: []
-    },
-    dirs: PYTHON_ENTRYPOINT_DIRS
+    }
   };
   try {
     const subdirs = await getSubdirectories(workPath);
     const rootDirs = ["", ...subdirs];
     for (const rootDir of rootDirs) {
-      const currPath = (0, import_path8.join)(workPath, rootDir);
+      const currPath = (0, import_path7.join)(workPath, rootDir);
       const isDjango = await checkDjangoManage(currPath);
       if (isDjango) {
         return {
           detected: { baseDir: rootDir },
-          findDiagnostics: { entrypoint: null, existingWithoutEntrypoint: [] },
-          dirs: rootDirs
+          findDiagnostics: { entrypoint: null, existingWithoutEntrypoint: [] }
         };
       }
     }
@@ -5633,11 +5533,10 @@ async function detectDjangoPythonEntrypoint(workPath) {
     const result = await findValidEntrypoint(workPath, candidates);
     return {
       detected: result.entrypoint ? { entrypoint: result.entrypoint } : null,
-      findDiagnostics: result,
-      dirs: rootDirs
+      findDiagnostics: result
     };
   } catch {
-    (0, import_build_utils9.debug)("Failed to discover Django Python entrypoint");
+    (0, import_build_utils8.debug)("Failed to discover Django Python entrypoint");
     return emptyResult;
   }
 }
@@ -5645,10 +5544,10 @@ async function detectPythonEntrypoint(framework, workPath, configuredEntrypoint,
   if (configuredEntrypoint) {
     const { filePath: configEntryFile, varName: configEntryVar } = configuredEntrypoint;
     const entrypoint = configEntryFile.endsWith(".py") ? configEntryFile : `${configEntryFile}.py`;
-    const entrypointExists = await fileExists((0, import_path8.join)(workPath, entrypoint));
+    const entrypointExists = await fileExists((0, import_path7.join)(workPath, entrypoint));
     if (!entrypointExists) {
       return {
-        error: new import_build_utils8.NowBuildError({
+        error: new import_build_utils7.NowBuildError({
           code: "PYTHON_ENTRYPOINT_NOT_FOUND",
           message: `Configured Python entrypoint "${entrypoint}" was not found.`,
           link: PYTHON_ENTRYPOINT_DOCS_URL,
@@ -5658,17 +5557,17 @@ async function detectPythonEntrypoint(framework, workPath, configuredEntrypoint,
     }
     let varName = configEntryVar ?? await checkEntrypoint(workPath, entrypoint);
     if (!varName) {
-      const needsDynamicApp = !!service && ((0, import_build_utils8.isScheduleTriggeredService)(service) || (0, import_build_utils8.isQueueTriggeredService)(service));
+      const needsDynamicApp = !!service && ((0, import_build_utils7.isScheduleTriggeredService)(service) || (0, import_build_utils7.isQueueTriggeredService)(service));
       if (needsDynamicApp) {
         varName = "app";
       }
     }
     if (varName) {
-      (0, import_build_utils9.debug)(`Using configured Python entrypoint: ${entrypoint}`);
+      (0, import_build_utils8.debug)(`Using configured Python entrypoint: ${entrypoint}`);
       return { entrypoint: { entrypoint, variableName: varName } };
     } else {
       return {
-        error: new import_build_utils8.NowBuildError({
+        error: new import_build_utils7.NowBuildError({
           code: "PYTHON_ENTRYPOINT_NOT_FOUND",
           message: `Could not find a top-level "app", "application", or "handler" in "${entrypoint}".`,
           link: PYTHON_ENTRYPOINT_DOCS_URL,
@@ -5684,36 +5583,18 @@ async function detectPythonEntrypoint(framework, workPath, configuredEntrypoint,
   if (vercelEntry)
     return { entrypoint: vercelEntry };
   let findDiagnostics;
-  let searchDirs;
+  let djangoManageBaseDir;
   if (framework === "django") {
     const djangoResult = await detectDjangoPythonEntrypoint(workPath);
     findDiagnostics = djangoResult.findDiagnostics;
-    searchDirs = djangoResult.dirs;
     if (djangoResult.detected) {
       if (djangoResult.detected.entrypoint)
         return djangoResult.detected;
-      const candidateSet2 = new Set(getCandidateEntrypointsInDirs(searchDirs));
-      const otherPyFiles2 = await findOtherPyFiles(
-        workPath,
-        searchDirs,
-        candidateSet2
-      );
-      const pyprojectResult2 = await getPyprojectEntrypointWithDiagnostics(workPath);
-      const diagnostics3 = {
-        existingWithoutEntrypoint: findDiagnostics.existingWithoutEntrypoint,
-        otherPyFiles: otherPyFiles2,
-        pyprojectAppScript: pyprojectResult2.appScript,
-        pyprojectCheckedPaths: pyprojectResult2.checkedPaths
-      };
-      return {
-        baseDir: djangoResult.detected.baseDir,
-        error: makeDiagnosticError("django", diagnostics3)
-      };
+      djangoManageBaseDir = djangoResult.detected.baseDir;
     }
   } else {
     const genericResult = await detectGenericPythonEntrypoint(workPath);
     findDiagnostics = genericResult.findDiagnostics;
-    searchDirs = PYTHON_ENTRYPOINT_DIRS;
     if (genericResult.detected)
       return genericResult.detected;
   }
@@ -5721,22 +5602,183 @@ async function detectPythonEntrypoint(framework, workPath, configuredEntrypoint,
   if (pyprojectResult.entrypoint) {
     return { entrypoint: pyprojectResult.entrypoint };
   }
-  const candidateSet = new Set(getCandidateEntrypointsInDirs(searchDirs));
-  const otherPyFiles = await findOtherPyFiles(
-    workPath,
-    searchDirs,
-    candidateSet
-  );
+  const validCandidatesElsewhere = await findEntrypointCandidates(workPath);
   const diagnostics2 = {
     existingWithoutEntrypoint: findDiagnostics.existingWithoutEntrypoint,
-    otherPyFiles,
     pyprojectAppScript: pyprojectResult.appScript,
-    pyprojectCheckedPaths: pyprojectResult.checkedPaths
+    pyprojectCheckedPaths: pyprojectResult.checkedPaths,
+    validCandidatesElsewhere,
+    djangoManageBaseDir
+  };
+  const error = makeDiagnosticError(framework, diagnostics2);
+  return djangoManageBaseDir !== void 0 ? { baseDir: djangoManageBaseDir, error } : { error };
+}
+var detectEntrypoint = async ({
+  workPath,
+  framework
+}) => {
+  if (!(0, import_build_utils7.isPythonFramework)(framework))
+    return null;
+  const detected = await detectPythonEntrypoint(
+    framework,
+    workPath
+  );
+  if (!detected?.entrypoint)
+    return null;
+  const { entrypoint, variableName } = detected.entrypoint;
+  return {
+    kind: "py-module:attr",
+    entrypoint: `${entrypointToModule(entrypoint)}:${variableName}`
   };
-  return { error: makeDiagnosticError(framework, diagnostics2) };
+};
+
+// src/crons.ts
+var DYNAMIC_SCHEDULE = "<dynamic>";
+var scriptPath = (0, import_path8.join)(__dirname, "..", "templates", "vc_cron_detect.py");
+var script = import_fs8.default.readFileSync(scriptPath, "utf-8");
+function buildCronRouteTable(crons) {
+  const table = {};
+  for (const cron of crons) {
+    table[cron.path] = cron.resolvedHandler;
+  }
+  return table;
+}
+async function getServiceCrons(opts) {
+  const { service, entrypoint, rawEntrypoint, handlerFunction } = opts;
+  const isScheduledService = !!service && (0, import_build_utils10.isScheduleTriggeredService)(service);
+  if (!isScheduledService || !service.name || typeof service.schedule !== "string" && !Array.isArray(service.schedule)) {
+    return void 0;
+  }
+  const cronEntrypoint = entrypoint || rawEntrypoint;
+  if (!cronEntrypoint) {
+    throw new import_build_utils10.NowBuildError({
+      code: "PYTHON_CRON_NO_ENTRYPOINT",
+      message: "Cron service is missing an entrypoint."
+    });
+  }
+  if (service.schedule === DYNAMIC_SCHEDULE) {
+    return getServiceCronsDynamic({
+      serviceName: service.name,
+      cronEntrypoint,
+      handlerFunction,
+      pythonBin: opts.pythonBin,
+      env: opts.env,
+      workPath: opts.workPath
+    });
+  }
+  const cronPath = (0, import_build_utils10.getInternalServiceCronPath)(
+    service.name,
+    cronEntrypoint,
+    handlerFunction || "cron"
+  );
+  const moduleName = entrypointToModule(cronEntrypoint);
+  const resolvedHandler = handlerFunction ? `${moduleName}:${handlerFunction}` : moduleName;
+  const schedules = Array.isArray(service.schedule) ? service.schedule : [service.schedule];
+  return schedules.map((schedule) => ({
+    path: cronPath,
+    schedule,
+    resolvedHandler
+  }));
+}
+async function getServiceCronsDynamic(opts) {
+  const {
+    serviceName,
+    cronEntrypoint,
+    handlerFunction,
+    pythonBin,
+    env,
+    workPath
+  } = opts;
+  if (!handlerFunction) {
+    throw new import_build_utils10.NowBuildError({
+      code: "PYTHON_DYNAMIC_CRON_NO_HANDLER",
+      message: 'Dynamic cron detection requires a "module:object" entrypoint where the object has a get_crons() method.'
+    });
+  }
+  const moduleName = entrypointToModule(cronEntrypoint);
+  const entries = await detectDynamicCrons({
+    pythonBin,
+    env,
+    workPath,
+    moduleName,
+    attrName: handlerFunction
+  });
+  console.log(
+    `Detected ${entries.length} cron entry(s): ${entries.map((e) => `${e.module_function} (${e.schedule})`).join(", ")}`
+  );
+  if (entries.length === 0) {
+    throw new import_build_utils10.NowBuildError({
+      code: "PYTHON_DYNAMIC_CRON_EMPTY",
+      message: `Dynamic cron detection returned no entries. "${moduleName}.${handlerFunction}.get_crons()" returned an empty iterable.`
+    });
+  }
+  return entries.map((entry) => {
+    const cronPath = moduleColonFuncToCronPath(
+      serviceName,
+      entry.module_function
+    );
+    return {
+      path: cronPath,
+      schedule: entry.schedule,
+      resolvedHandler: entry.module_function
+    };
+  });
+}
+async function detectDynamicCrons(opts) {
+  const { pythonBin, env, workPath, moduleName, attrName } = opts;
+  let stdout;
+  try {
+    const result = await (0, import_execa4.default)(
+      pythonBin,
+      ["-c", script, moduleName, attrName],
+      { env, cwd: workPath }
+    );
+    stdout = result.stdout;
+  } catch (err) {
+    let detail = err?.stderr || err?.message || String(err);
+    try {
+      const parsed2 = JSON.parse(err?.stdout);
+      if (parsed2.error)
+        detail = parsed2.error;
+    } catch {
+    }
+    throw new import_build_utils10.NowBuildError({
+      code: "PYTHON_DYNAMIC_CRON_DETECTION_FAILED",
+      message: `Failed to detect dynamic cron entries: ${detail}`
+    });
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    throw new import_build_utils10.NowBuildError({
+      code: "PYTHON_DYNAMIC_CRON_DETECTION_FAILED",
+      message: `Dynamic cron detection returned invalid JSON: ${stdout}`
+    });
+  }
+  return parsed.entries || [];
+}
+function moduleColonFuncToCronPath(serviceName, moduleFunction) {
+  const colonIdx = moduleFunction.indexOf(":");
+  if (colonIdx === -1) {
+    throw new import_build_utils10.NowBuildError({
+      code: "PYTHON_DYNAMIC_CRON_INVALID_FORMAT",
+      message: `Dynamic cron entry must use "module:function" format, got: "${moduleFunction}"`
+    });
+  }
+  const modulePart = moduleFunction.slice(0, colonIdx);
+  const funcPart = moduleFunction.slice(colonIdx + 1);
+  const entrypointPath = modulePart.replace(/\./g, "/");
+  return (0, import_build_utils10.getInternalServiceCronPath)(serviceName, entrypointPath, funcPart);
 }
 
 // src/start-dev-server.ts
+var import_child_process2 = require("child_process");
+var import_fs9 = require("fs");
+var import_path9 = require("path");
+var import_build_utils11 = require("@vercel/build-utils");
+var import_get_port = __toESM(require_get_port());
+var import_is_port_reachable = __toESM(require_is_port_reachable());
 var import_python_analysis6 = require("@vercel/python-analysis");
 var DEV_SERVER_STARTUP_TIMEOUT = 5 * 6e4;
 function silenceNodeWarnings() {
@@ -6313,7 +6355,7 @@ var startDevServer = async (opts) => {
     });
   }
   const { entrypoint: entry, variableName } = resolved;
-  const modulePath = entry.replace(/\.py$/i, "").replace(/[\\/]/g, ".");
+  const modulePath = entrypointToModule(entry);
   let childProcess = null;
   let stdoutLogListener = null;
   let stderrLogListener = null;
@@ -7198,7 +7240,8 @@ var build = async ({
   meta = {},
   config,
   span: parentSpan,
-  service
+  service,
+  registerPreDeploy
 }) => {
   let entrypoint = rawEntrypoint === "<detect>" ? void 0 : rawEntrypoint;
   const builderSpan = parentSpan ?? new import_build_utils16.Span({ name: "vc.builder" });
@@ -7442,7 +7485,7 @@ var build = async ({
   await uv.pip({
     venvPath,
     projectDir: (0, import_path13.join)(workPath, entryDirectory),
-    args: ["install", runtimeDep]
+    args: ["install", "--link-mode", "copy", runtimeDep]
   });
   if (shouldInstallVercelWorkers) {
     const workersDep = baseEnv.VERCEL_WORKERS_PYTHON || `vercel-workers==${VERCEL_WORKERS_VERSION}`;
@@ -7450,15 +7493,31 @@ var build = async ({
     await uv.pip({
       venvPath,
       projectDir: (0, import_path13.join)(workPath, entryDirectory),
-      args: ["install", workersDep]
+      args: ["install", "--link-mode", "copy", workersDep]
     });
   }
   const quirksResult = await runQuirks({ venvPath, pythonEnv, workPath });
   if (quirksResult.buildEnv) {
     Object.assign(pythonEnv, quirksResult.buildEnv);
   }
+  const preDeployCommand = config?.preDeployCommand;
+  if (registerPreDeploy && typeof preDeployCommand === "string") {
+    const capturedEnv = { ...pythonEnv };
+    const capturedCwd = workPath;
+    registerPreDeploy(async () => {
+      await builderSpan.child(import_build_utils16.BUILDER_PRE_DEPLOY_STEP, {
+        preDeployCommand
+      }).trace(async () => {
+        console.log(`Running pre-deploy command: \`${preDeployCommand}\``);
+        await (0, import_build_utils16.execCommand)(preDeployCommand, {
+          env: capturedEnv,
+          cwd: capturedCwd
+        });
+      });
+    });
+  }
   (0, import_build_utils16.debug)("Entrypoint is", entrypoint);
-  const moduleName = entrypoint.replace(/\//g, ".").replace(/\.py$/i, "");
+  const moduleName = entrypointToModule(entrypoint);
   if (handlerFunction) {
     const entrypointPath = (0, import_path13.join)(workPath, entrypoint);
     const source = await import_fs13.default.promises.readFile(entrypointPath, "utf-8");
@@ -7697,6 +7756,7 @@ function hasProp(obj, key) {
 0 && (module.exports = {
   build,
   defaultShouldServe,
+  detectEntrypoint,
   diagnostics,
   downloadFilesInWorkPath,
   installRequirement,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/python",
-  "version": "6.40.0",
+  "version": "6.42.0",
   "main": "./dist/index.js",
   "license": "Apache-2.0",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/python",
@@ -34,7 +34,7 @@
     "smol-toml": "1.5.2",
     "vitest": "2.1.4",
     "which": "3.0.0",
-    "@vercel/build-utils": "13.23.0",
+    "@vercel/build-utils": "13.25.0",
     "@vercel/error-utils": "2.1.0",
     "@vercel/python-runtime": "0.13.2"
   },