@vercel/python 15.0.0 → 17.0.0

package/dist/index.js

@@ -6640,7 +6640,7 @@ minimatch.unescape = unescape;
 var import_path21 = require("path");
 
 // src/package-versions.ts
-var VERCEL_RUNTIME_VERSION = "0.23.0";
+var VERCEL_RUNTIME_VERSION = "0.23.1";
 var VERCEL_WORKERS_VERSION = "0.0.25";
 
 // src/conditional-vendoring.ts
@@ -12939,6 +12939,7 @@ function getImportClosureOptions({
 }
 
 // src/index.ts
+var import_build_utils25 = require("@vercel/build-utils");
 var writeFile = import_fs20.default.promises.writeFile;
 var PYTHON_ENTRYPOINT_DOCS_URL2 = "https://vercel.com/docs/functions/runtimes/python#python-entrypoints";
 var version = -1;
@@ -13786,6 +13787,175 @@ async function packFunctionBundle({
   });
   return { pycachePrefix, vendorDir, files };
 }
+async function buildProxyMiddleware({
+  workPath,
+  repoRootPath,
+  files: originalFiles,
+  entrypoint,
+  config,
+  meta,
+  builderSpan
+}) {
+  const target = getTargetPlatform(meta.isDev ?? false);
+  (0, import_build_utils24.debug)(`workPath: ${workPath}`);
+  workPath = await downloadFilesInWorkPath({
+    workPath,
+    files: originalFiles,
+    entrypoint,
+    meta
+  });
+  const proxyHandlerFunction = config.handlerFunction;
+  if (typeof proxyHandlerFunction !== "string" || !proxyHandlerFunction) {
+    throw new Error(
+      'Python proxy build requires "config.handlerFunction" to be set'
+    );
+  }
+  const proxySource = await import_fs20.default.promises.readFile(
+    (0, import_path21.join)(workPath, entrypoint),
+    "utf-8"
+  );
+  if (!await (0, import_python_analysis12.containsTopLevelCallable)(proxySource, proxyHandlerFunction)) {
+    throw new import_build_utils24.NowBuildError({
+      code: "PYTHON_HANDLER_NOT_FOUND",
+      message: `Handler function "${proxyHandlerFunction}" not found in ${entrypoint}. Ensure it is defined at the module's top level.`
+    });
+  }
+  const rootDir = repoRootPath ?? workPath;
+  const venvPath = (0, import_path21.join)(workPath, ".vercel", "python", "vercel.proxy", ".venv");
+  const { pythonPackage, pythonVersion, uv, uvCacheDir, restoredCache } = await setupPythonToolchain({
+    builderSpan,
+    workPath,
+    entrypointDir: (0, import_path21.join)(workPath, (0, import_path21.dirname)(entrypoint)),
+    rootDir,
+    venvPath,
+    meta
+  });
+  const { projectDir, lockPath: uvLockPath } = await builderSpan.child(import_build_utils24.BUILDER_INSTALLER_STEP, {
+    runtime: "python",
+    "python.cache.restored": restoredCache
+  }).trace(
+    () => runUvManagedInstall({
+      workPath,
+      rootDir,
+      venvPath,
+      pythonPackage,
+      pythonVersion,
+      uv,
+      uvCacheDir,
+      lockCacheKey: "uv.lock",
+      pythonPlatform: target.uvPlatform,
+      // Install only the proxy's dependency group into the proxy venv;
+      // the project itself is neither built nor installed.
+      // If the group is absent the proxy has no extra deps — skip sync.
+      extraSyncParams: "vercel.proxy" in (pythonPackage?.manifest?.data?.["dependency-groups"] ?? {}) ? { onlyGroup: "vercel.proxy", noInstallProject: true } : void 0
+    })
+  );
+  const pipPlatformArgs = target.uvPlatform ? ["--python-platform", target.uvPlatform] : [];
+  await installInjectedPackage({
+    name: "vercel-runtime",
+    requirement: `vercel-runtime==${VERCEL_RUNTIME_VERSION}`,
+    envOverride: process.env.VERCEL_RUNTIME_PYTHON,
+    allowLocalSource: true,
+    uv,
+    venvPath,
+    projectDir,
+    pipPlatformArgs
+  });
+  const projectName = pythonPackage?.manifest?.data?.project?.name;
+  const compileAllEnabled = shouldCompileAll({
+    isDev: meta.isDev ?? false,
+    hasCustomCommand: false
+  });
+  const pythonEnv = createVenvEnv(venvPath, process.env, uvCacheDir);
+  const functionConfig = getMatchingFunction(
+    config,
+    entrypoint
+  )?.functionConfig;
+  const includeFilesPatterns = [
+    ...normalizeGlobs(config?.includeFiles),
+    ...normalizeGlobs(functionConfig?.includeFiles)
+  ];
+  const excludeFilesPatterns = [
+    ...normalizeGlobs(config?.excludeFiles),
+    ...normalizeGlobs(functionConfig?.excludeFiles)
+  ];
+  const initialFiles = {};
+  for (const pattern of includeFilesPatterns) {
+    Object.assign(initialFiles, await (0, import_build_utils24.glob)(pattern, workPath));
+  }
+  const { pycachePrefix, vendorDir, files } = await packFunctionBundle({
+    builderSpan,
+    workPath,
+    uvLockPath,
+    uvProjectDir: projectDir,
+    projectName,
+    pythonVersion,
+    hasCustomCommand: false,
+    alwaysBundlePackages: [],
+    initialFiles,
+    additionalExcludes: excludeFilesPatterns,
+    compileAllEnabled,
+    compileEnv: pythonEnv,
+    venvPath,
+    entrypoint,
+    importClosureContext: {
+      frameworkSeeds: [],
+      extraPythonPath: void 0,
+      subscriberDeclarations: [],
+      subscribers: [],
+      workflows: [],
+      workflowMode: "workers"
+    },
+    largeFunctionLabel: entrypoint
+  });
+  const moduleName = entrypointToModule(entrypoint);
+  const variableName = proxyHandlerFunction;
+  const handlerPyFilename = "vc__handler__python";
+  const runtimeTrampoline = createRuntimeTrampoline({
+    moduleName,
+    entrypoint,
+    vendorDir,
+    variableName,
+    extraEnv: []
+  });
+  files[`${handlerPyFilename}.py`] = new import_build_utils24.FileBlob({ data: runtimeTrampoline });
+  const lambdaOptions = await getPythonLambdaOptions({ config, entrypoint });
+  const output = new import_build_utils24.Lambda({
+    files,
+    handler: `${handlerPyFilename}.vc_handler`,
+    runtime: pythonVersion.runtime,
+    ...lambdaOptions,
+    architecture: target.architecture,
+    environment: {
+      PYTHONPATH: vendorDir,
+      PYTHONDONTWRITEBYTECODE: "1",
+      ...pycachePrefix ? { PYTHONPYCACHEPREFIX: pycachePrefix } : {}
+    },
+    supportsResponseStreaming: true
+  });
+  const matcher = (0, import_build_utils25.resolveMiddlewareMatcher)(
+    config.middlewareMatcher,
+    void 0,
+    entrypoint
+  );
+  const src = (0, import_build_utils25.getRegExpFromMatchers)(matcher);
+  const middlewareRawSrc = !matcher ? [] : Array.isArray(matcher) ? [...matcher] : [matcher];
+  return {
+    resultVersion: 3,
+    result: {
+      output,
+      routes: [
+        {
+          src,
+          middlewareRawSrc,
+          middlewarePath: entrypoint.replace(/\.py$/i, ""),
+          continue: true,
+          override: true
+        }
+      ]
+    }
+  };
+}
 var build = async ({
   workPath,
   repoRootPath,
@@ -13797,14 +13967,19 @@ var build = async ({
   service,
   registerPreDeploy
 }) => {
-  if (config?.middleware === true) {
-    throw new import_build_utils24.NowBuildError({
-      code: "PYTHON_PROXY_NOT_IMPLEMENTED",
-      message: "Python proxy middleware is not yet supported."
-    });
-  }
   let entrypoint = rawEntrypoint === "<detect>" ? void 0 : rawEntrypoint;
   const builderSpan = parentSpan ?? new import_build_utils24.Span({ name: "vc.builder" });
+  if (config?.middleware === true && entrypoint) {
+    return buildProxyMiddleware({
+      workPath,
+      repoRootPath,
+      files: originalFiles,
+      entrypoint,
+      config,
+      meta,
+      builderSpan
+    });
+  }
   const isPyprojectEntrypoint = entrypoint !== void 0 && (0, import_path21.basename)(entrypoint) === "pyproject.toml";
   if (isPyprojectEntrypoint && entrypoint !== "pyproject.toml") {
     throw new import_build_utils24.NowBuildError({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/python",
-  "version": "15.0.0",
+  "version": "17.0.0",
   "main": "./dist/index.js",
   "license": "Apache-2.0",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/python",
@@ -17,7 +17,7 @@
     "@vercel/python-analysis": "0.14.0"
   },
   "peerDependencies": {
-    "@vercel/build-utils": "14.11.0"
+    "@vercel/build-utils": "14.13.0"
   },
   "devDependencies": {
     "@renovatebot/pep440": "4.2.1",
@@ -38,9 +38,9 @@
     "smol-toml": "1.5.2",
     "vitest": "4.1.10",
     "which": "3.0.0",
-    "@vercel/build-utils": "14.11.0",
+    "@vercel/build-utils": "14.13.0",
     "@vercel/error-utils": "2.2.1",
-    "@vercel/python-runtime": "0.23.0"
+    "@vercel/python-runtime": "0.23.1"
   },
   "scripts": {
     "build": "node ../../utils/build-builder.mjs",