@vercel/build-utils 13.3.0 → 13.3.2

package/dist/python.d.ts

@@ -1,17 +1,4 @@
 import FileFsRef from './file-fs-ref';
-/**
- * Run a Python script that only uses the standard library.
- */
-export declare function runStdlibPyScript(options: {
-    scriptName: string;
-    pythonPath?: string;
-    args?: string[];
-    cwd?: string;
-}): Promise<{
-    exitCode: number;
-    stdout: string;
-    stderr: string;
-}>;
 /**
  * Check if a Python file is a valid entrypoint by detecting:
  * - A top-level 'app' callable (Flask, FastAPI, Sanic, WSGI/ASGI, etc.)

package/dist/python.js

@@ -28,51 +28,19 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var python_exports = {};
 __export(python_exports, {
-  isPythonEntrypoint: () => isPythonEntrypoint,
-  runStdlibPyScript: () => runStdlibPyScript
+  isPythonEntrypoint: () => isPythonEntrypoint
 });
 module.exports = __toCommonJS(python_exports);
 var import_fs = __toESM(require("fs"));
-var import_path = require("path");
-var import_execa = __toESM(require("execa"));
+var import_python_analysis = require("@vercel/python-analysis");
 var import_debug = __toESM(require("./debug"));
-const isWin = process.platform === "win32";
-async function runStdlibPyScript(options) {
-  const { scriptName, pythonPath, args = [], cwd } = options;
-  const scriptPath = (0, import_path.join)(__dirname, "..", "lib", "python", `${scriptName}.py`);
-  if (!import_fs.default.existsSync(scriptPath)) {
-    throw new Error(`Python script not found: ${scriptPath}`);
-  }
-  const pythonCmd = pythonPath ?? (isWin ? "python" : "python3");
-  (0, import_debug.default)(
-    `Running stdlib Python script: ${pythonCmd} ${scriptPath} ${args.join(" ")}`
-  );
-  try {
-    const result = await (0, import_execa.default)(pythonCmd, [scriptPath, ...args], { cwd });
-    return { exitCode: 0, stdout: result.stdout, stderr: result.stderr };
-  } catch (err) {
-    const execaErr = err;
-    return {
-      exitCode: execaErr.exitCode ?? 1,
-      stdout: execaErr.stdout ?? "",
-      stderr: execaErr.stderr ?? ""
-    };
-  }
-}
 async function isPythonEntrypoint(file) {
   try {
     const fsPath = file.fsPath;
     if (!fsPath)
       return false;
     const content = await import_fs.default.promises.readFile(fsPath, "utf-8");
-    if (!content.includes("app") && !content.includes("handler") && !content.includes("Handler")) {
-      return false;
-    }
-    const result = await runStdlibPyScript({
-      scriptName: "ast_parser",
-      args: [fsPath]
-    });
-    return result.exitCode === 0;
+    return await (0, import_python_analysis.containsAppOrHandler)(content);
   } catch (err) {
     (0, import_debug.default)(`Failed to check Python entrypoint: ${err}`);
     return false;
@@ -80,6 +48,5 @@ async function isPythonEntrypoint(file) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  isPythonEntrypoint,
-  runStdlibPyScript
+  isPythonEntrypoint
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/build-utils",
-  "version": "13.3.0",
+  "version": "13.3.2",
   "license": "Apache-2.0",
   "main": "./dist/index.js",
   "types": "./dist/index.d.js",
@@ -10,6 +10,9 @@
     "url": "https://github.com/vercel/vercel.git",
     "directory": "packages/now-build-utils"
   },
+  "dependencies": {
+    "@vercel/python-analysis": "0.3.1"
+  },
   "devDependencies": {
     "@iarna/toml": "2.2.3",
     "@types/async-retry": "^1.2.1",
@@ -47,8 +50,8 @@
     "yazl": "2.5.1",
     "vitest": "2.0.1",
     "json5": "2.2.3",
-    "@vercel/error-utils": "2.0.3",
-    "@vercel/routing-utils": "5.3.2"
+    "@vercel/routing-utils": "5.3.2",
+    "@vercel/error-utils": "2.0.3"
   },
   "scripts": {
     "build": "node build.mjs",

package/lib/python/ast_parser.py

@@ -1,72 +0,0 @@
-import sys
-import ast
-
-
-def contains_app_or_handler(file_path: str) -> bool:
-    """
-    Check if a Python file contains or exports:
-    - A top-level 'app' callable (e.g., Flask, FastAPI, Sanic apps)
-    - A top-level 'handler' class (e.g., BaseHTTPRequestHandler subclass)
-    """
-    with open(file_path, "r") as file:
-        code = file.read()
-
-    try:
-        tree = ast.parse(code)
-    except SyntaxError:
-        return False
-
-    for node in ast.iter_child_nodes(tree):
-        # Check for top-level assignment to 'app'
-        # e.g., app = Sanic() or app = Flask(__name__) or app = create_app()
-        if isinstance(node, ast.Assign):
-            for target in node.targets:
-                if isinstance(target, ast.Name) and target.id == "app":
-                    return True
-
-        # Check for annotated assignment to 'app'
-        # e.g., app: Sanic = Sanic()
-        if isinstance(node, ast.AnnAssign):
-            if isinstance(node.target, ast.Name) and node.target.id == "app":
-                return True
-
-        # Check for function named 'app'
-        # e.g., def app(environ, start_response): ...
-        if isinstance(node, ast.FunctionDef) and node.name == "app":
-            return True
-
-        # Check for async function named 'app'
-        # e.g., async def app(scope, receive, send): ...
-        if isinstance(node, ast.AsyncFunctionDef) and node.name == "app":
-            return True
-
-        # Check for import of 'app'
-        # e.g., from server import app
-        # e.g., from server import application as app
-        if isinstance(node, ast.ImportFrom):
-            for alias in node.names:
-                # alias.asname is the 'as' name, alias.name is the original name
-                # If aliased, check asname; otherwise check the original name
-                imported_as = alias.asname if alias.asname else alias.name
-                if imported_as == "app":
-                    return True
-
-        # Check for top-level class named 'handler'
-        # e.g., class handler(BaseHTTPRequestHandler):
-        if isinstance(node, ast.ClassDef) and node.name.lower() == "handler":
-            return True
-
-    return False
-
-
-if __name__ == "__main__":
-    if len(sys.argv) != 2:
-        print("Usage: python ast_parser.py <file_path>")
-        sys.exit(1)
-
-    file_path = sys.argv[1]
-    result = contains_app_or_handler(file_path)
-
-    # Exit with 0 if found, 1 if not found
-    sys.exit(0 if result else 1)
-

package/lib/python/tests/test_ast_parser.py

@@ -1,72 +0,0 @@
-import unittest
-import tempfile
-import os
-import sys
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).parent.parent))
-
-from ast_parser import contains_app_or_handler
-
-
-class TestContainsAppOrHandler(unittest.TestCase):
-    def _check(self, code: str) -> bool:
-        """Helper to test code snippets without needing fixture files."""
-        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
-            f.write(code)
-            f.flush()
-            try:
-                return contains_app_or_handler(f.name)
-            finally:
-                os.unlink(f.name)
-
-    def test_flask_app(self):
-        self.assertTrue(self._check("from flask import Flask\napp = Flask(__name__)"))
-
-    def test_fastapi_app(self):
-        self.assertTrue(self._check("from fastapi import FastAPI\napp = FastAPI()"))
-
-    def test_sanic_app(self):
-        self.assertTrue(self._check("from sanic import Sanic\napp = Sanic('app')"))
-
-    def test_annotated_app(self):
-        self.assertTrue(self._check("from fastapi import FastAPI\napp: FastAPI = FastAPI()"))
-
-    def test_wsgi_function(self):
-        self.assertTrue(self._check("def app(environ, start_response):\n    pass"))
-
-    def test_asgi_function(self):
-        self.assertTrue(self._check("async def app(scope, receive, send):\n    pass"))
-
-    def test_imported_app(self):
-        self.assertTrue(self._check("from server import app"))
-
-    def test_imported_app_aliased(self):
-        self.assertTrue(self._check("from server import application as app"))
-
-    def test_handler_class(self):
-        self.assertTrue(self._check("class Handler:\n    pass"))
-
-    def test_handler_class_lowercase(self):
-        self.assertTrue(self._check("class handler:\n    pass"))
-
-    def test_no_app_or_handler(self):
-        self.assertFalse(self._check("def hello():\n    return 'world'"))
-
-    def test_app_in_function_not_toplevel(self):
-        # app defined inside a function should NOT match
-        self.assertFalse(self._check("def create():\n    app = Flask(__name__)\n    return app"))
-
-    def test_syntax_error(self):
-        self.assertFalse(self._check("def broken("))
-
-    def test_empty_file(self):
-        self.assertFalse(self._check(""))
-
-    def test_only_comments(self):
-        self.assertFalse(self._check("# just a comment\n# another comment"))
-
-
-if __name__ == "__main__":
-    unittest.main()
-