@vercel/python-analysis 0.2.0 → 0.3.0

package/dist/index.d.ts

@@ -6,6 +6,7 @@
  *
  * @module @vercel/python-analysis
  */
+export { containsAppOrHandler } from './semantic/entrypoints';
 export type { PythonConfig, PythonConfigs, PythonManifest, PythonManifestOrigin, PythonPackage, PythonVersionConfig, } from './manifest/package';
 export { discoverPythonPackage, PythonConfigKind, PythonManifestConvertedKind, PythonManifestKind, } from './manifest/package';
 export type { PythonSelectionResult } from './manifest/python-selector';

package/dist/index.js

@@ -53,10 +53,12 @@ __export(src_exports, {
   UvConfigSchema: () => import_schema2.UvConfigSchema,
   UvConfigWorkspaceSchema: () => import_schema2.UvConfigWorkspaceSchema,
   UvIndexEntrySchema: () => import_schema2.UvIndexEntrySchema,
+  containsAppOrHandler: () => import_entrypoints.containsAppOrHandler,
   discoverPythonPackage: () => import_package.discoverPythonPackage,
   selectPython: () => import_python_selector.selectPython
 });
 module.exports = __toCommonJS(src_exports);
+var import_entrypoints = require("./semantic/entrypoints");
 var import_package = require("./manifest/package");
 var import_python_selector = require("./manifest/python-selector");
 var import_error = require("./util/error");
@@ -102,6 +104,7 @@ var import_python_specifiers = require("./manifest/python-specifiers");
   UvConfigSchema,
   UvConfigWorkspaceSchema,
   UvIndexEntrySchema,
+  containsAppOrHandler,
   discoverPythonPackage,
   selectPython
 });

package/dist/semantic/entrypoints.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Semantic analyzer for detecting application entrypoint patterns in Python
+ * source code.
+ */
+/**
+ * Check if Python source code contains or exports:
+ * - A top-level 'app' callable (e.g., Flask, FastAPI, Sanic apps)
+ * - A top-level 'handler' class (e.g., BaseHTTPRequestHandler subclass)
+ *
+ * This function uses a WASM-based Python parser (ruff_python_ast) for
+ * accurate AST analysis without requiring a Python runtime.
+ *
+ * @param source - The Python source code to analyze
+ * @returns Promise that resolves to true if an app or handler is found, false otherwise.
+ *          Returns false for invalid Python syntax.
+ *
+ * @example
+ * ```typescript
+ * import { containsAppOrHandler } from '@vercel/python-analysis';
+ *
+ * const hasApp = await containsAppOrHandler(`
+ * from flask import Flask
+ * app = Flask(__name__)
+ * `);
+ * console.log(hasApp); // true
+ * ```
+ */
+export declare function containsAppOrHandler(source: string): Promise<boolean>;

package/dist/semantic/entrypoints.js

@@ -0,0 +1,32 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var entrypoints_exports = {};
+__export(entrypoints_exports, {
+  containsAppOrHandler: () => containsAppOrHandler
+});
+module.exports = __toCommonJS(entrypoints_exports);
+var import_load = require("./load");
+async function containsAppOrHandler(source) {
+  const mod = await (0, import_load.importWasmModule)();
+  return mod.containsAppOrHandler(source);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  containsAppOrHandler
+});

package/dist/semantic/load.d.ts

@@ -0,0 +1,4 @@
+type ModuleType = typeof import('#wasm/vercel_python_analysis.js');
+type RootType = Awaited<ReturnType<ModuleType['instantiate']>>;
+export declare function importWasmModule(): Promise<RootType>;
+export {};

package/dist/semantic/load.js

@@ -0,0 +1,66 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var load_exports = {};
+__export(load_exports, {
+  importWasmModule: () => importWasmModule
+});
+module.exports = __toCommonJS(load_exports);
+var import_promises = require("node:fs/promises");
+var import_node_path = require("node:path");
+let wasmInstance = null;
+let wasmLoadPromise = null;
+const wasmModulePath = require.resolve("#wasm/vercel_python_analysis.js");
+const wasmDir = (0, import_node_path.dirname)(wasmModulePath);
+async function getCoreModule(path) {
+  const wasmPath = (0, import_node_path.join)(wasmDir, path);
+  const wasmBytes = await (0, import_promises.readFile)(wasmPath);
+  return WebAssembly.compile(wasmBytes);
+}
+async function importWasmModule() {
+  if (wasmInstance) {
+    return wasmInstance;
+  }
+  if (!wasmLoadPromise) {
+    wasmLoadPromise = (async () => {
+      const {
+        WASIShim
+      } = require("@bytecodealliance/preview2-shim/instantiation");
+      const wasmModule = require("#wasm/vercel_python_analysis.js");
+      const imports = new WASIShim().getImportObject();
+      const instance = await wasmModule.instantiate(getCoreModule, imports);
+      wasmInstance = instance;
+      return instance;
+    })();
+  }
+  return wasmLoadPromise;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  importWasmModule
+});

package/dist/wasm/interfaces/wasi-cli-environment.d.ts

@@ -0,0 +1,2 @@
+/** @module Interface wasi:cli/environment@0.2.6 **/
+export function getEnvironment(): Array<[string, string]>;

package/dist/wasm/interfaces/wasi-cli-exit.d.ts

@@ -0,0 +1,3 @@
+/** @module Interface wasi:cli/exit@0.2.6 **/
+export function exit(status: Result<void, void>): void;
+export type Result<T, E> = { tag: 'ok', val: T } | { tag: 'err', val: E };

package/dist/wasm/interfaces/wasi-cli-stderr.d.ts

@@ -0,0 +1,3 @@
+/** @module Interface wasi:cli/stderr@0.2.6 **/
+export function getStderr(): OutputStream;
+export type OutputStream = import('./wasi-io-streams.js').OutputStream;

package/dist/wasm/interfaces/wasi-io-error.d.ts

@@ -0,0 +1,9 @@
+/** @module Interface wasi:io/error@0.2.6 **/
+
+export class Error {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
+  toDebugString(): string;
+}

package/dist/wasm/interfaces/wasi-io-streams.d.ts

@@ -0,0 +1,18 @@
+/** @module Interface wasi:io/streams@0.2.6 **/
+export type Error = import('./wasi-io-error.js').Error;
+export type StreamError = StreamErrorLastOperationFailed | StreamErrorClosed;
+export interface StreamErrorLastOperationFailed {
+  tag: 'last-operation-failed',
+  val: Error,
+}
+export interface StreamErrorClosed {
+  tag: 'closed',
+}
+
+export class OutputStream {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
+  blockingWriteAndFlush(contents: Uint8Array): void;
+}

package/dist/wasm/vercel_python_analysis.d.ts

@@ -0,0 +1,47 @@
+// world root:component/root
+import type * as WasiCliEnvironment from './interfaces/wasi-cli-environment.js'; // wasi:cli/environment@0.2.6
+import type * as WasiCliExit from './interfaces/wasi-cli-exit.js'; // wasi:cli/exit@0.2.6
+import type * as WasiCliStderr from './interfaces/wasi-cli-stderr.js'; // wasi:cli/stderr@0.2.6
+import type * as WasiIoError from './interfaces/wasi-io-error.js'; // wasi:io/error@0.2.6
+import type * as WasiIoStreams from './interfaces/wasi-io-streams.js'; // wasi:io/streams@0.2.6
+export interface ImportObject {
+  'wasi:cli/environment@0.2.6': typeof WasiCliEnvironment,
+  'wasi:cli/exit@0.2.6': typeof WasiCliExit,
+  'wasi:cli/stderr@0.2.6': typeof WasiCliStderr,
+  'wasi:io/error@0.2.6': typeof WasiIoError,
+  'wasi:io/streams@0.2.6': typeof WasiIoStreams,
+}
+export interface Root {
+  containsAppOrHandler(source: string): boolean,
+}
+
+/**
+* Instantiates this component with the provided imports and
+* returns a map of all the exports of the component.
+*
+* This function is intended to be similar to the
+* `WebAssembly.instantiate` function. The second `imports`
+* argument is the "import object" for wasm, except here it
+* uses component-model-layer types instead of core wasm
+* integers/numbers/etc.
+*
+* The first argument to this function, `getCoreModule`, is
+* used to compile core wasm modules within the component.
+* Components are composed of core wasm modules and this callback
+* will be invoked per core wasm module. The caller of this
+* function is responsible for reading the core wasm module
+* identified by `path` and returning its compiled
+* `WebAssembly.Module` object. This would use `compileStreaming`
+* on the web, for example.
+*/
+export function instantiate(
+getCoreModule: (path: string) => WebAssembly.Module,
+imports: ImportObject,
+instantiateCore?: (module: WebAssembly.Module, imports: Record<string, any>) => WebAssembly.Instance
+): Root;
+export function instantiate(
+getCoreModule: (path: string) => WebAssembly.Module | Promise<WebAssembly.Module>,
+imports: ImportObject,
+instantiateCore?: (module: WebAssembly.Module, imports: Record<string, any>) => WebAssembly.Instance | Promise<WebAssembly.Instance>
+): Root | Promise<Root>;
+