@vercel/python-analysis 0.2.0 → 0.3.1

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/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/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>;
+