Upload folder using huggingface_hub

6.4.0/tootils/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@self/tootils",
-	"version": "0.8.3",
+	"version": "0.9.0",
 	"description": "Internal test utilities",
 	"type": "module",
 	"main": "src/index.ts",
@@ -16,7 +16,8 @@
 	},
 	"exports": {
 		".": "./src/index.ts",
-		"./render": "./src/render.ts"
+		"./render": "./src/render.ts",
+		"./app-launcher": "./src/app-launcher.ts"
 	},
 	"scripts": {
 		"package": "svelte-package --input=. --tsconfig=../../tsconfig.json"

6.4.0/tootils/src/app-launcher.ts

@@ -0,0 +1,174 @@
+import { spawn, type ChildProcess } from "node:child_process";
+import net from "net";
+import path from "path";
+import fs from "fs";
+import os from "os";
+import url from "url";
+
+const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
+const ROOT_DIR = path.resolve(__dirname, "../../..");
+
+export interface GradioApp {
+	port: number;
+	process: ChildProcess;
+}
+
+export function killGradioApp(process: ChildProcess): void {
+	try {
+		process.kill("SIGTERM");
+	} catch {
+		// Process may already be dead
+	}
+}
+
+export async function findFreePort(
+	startPort: number,
+	endPort: number
+): Promise<number> {
+	for (let port = startPort; port < endPort; port++) {
+		if (await isPortFree(port)) {
+			return port;
+		}
+	}
+	throw new Error(`Could not find free port in range ${startPort}-${endPort}`);
+}
+
+function isPortFree(port: number): Promise<boolean> {
+	return new Promise((resolve, reject) => {
+		const sock = net.createConnection(port, "127.0.0.1");
+		sock.once("connect", () => {
+			sock.end();
+			resolve(false);
+		});
+		sock.once("error", (e: NodeJS.ErrnoException) => {
+			sock.destroy();
+			if (e.code === "ECONNREFUSED") {
+				resolve(true);
+			} else {
+				reject(e);
+			}
+		});
+	});
+}
+
+export function getTestcases(demoName: string): string[] {
+	const demoDir = path.join(ROOT_DIR, "demo", demoName);
+	if (!fs.existsSync(demoDir)) {
+		return [];
+	}
+
+	return fs
+		.readdirSync(demoDir)
+		.filter((f) => f.endsWith("_testcase.py"))
+		.map((f) => path.basename(f, ".py"));
+}
+
+// Check if a testcase file exists for this demo
+export function hasTestcase(demoName: string, testcaseName: string): boolean {
+	const testcaseFile = path.join(
+		ROOT_DIR,
+		"demo",
+		demoName,
+		`${testcaseName}_testcase.py`
+	);
+	return fs.existsSync(testcaseFile);
+}
+
+// Get the path to a demo's Python file
+function getDemoFilePath(demoName: string, testcaseName?: string): string {
+	if (testcaseName) {
+		return path.join(ROOT_DIR, "demo", demoName, `${testcaseName}_testcase.py`);
+	}
+	return path.join(ROOT_DIR, "demo", demoName, "run.py");
+}
+
+export async function launchGradioApp(
+	demoName: string,
+	workerIndex: number = 0,
+	timeout: number = 60000,
+	testcaseName?: string
+): Promise<GradioApp> {
+	// Partition ports by worker index to avoid collisions
+	const basePort = 7860 + workerIndex * 100;
+	const port = await findFreePort(basePort, basePort + 99);
+
+	// Get the path to the demo file
+	const demoFilePath = getDemoFilePath(demoName, testcaseName);
+
+	// Create unique directories for this instance to avoid cache conflicts
+	const instanceId = testcaseName
+		? `${demoName}_${testcaseName}_${port}`
+		: `${demoName}_${port}`;
+	const instanceDir = path.join(os.tmpdir(), `gradio_test_${instanceId}`);
+	const cacheDir = path.join(instanceDir, "cached_examples");
+	const tempDir = path.join(instanceDir, "temp");
+
+	if (!fs.existsSync(instanceDir)) {
+		fs.mkdirSync(instanceDir, { recursive: true });
+	}
+
+	// Run the demo file directly - the demo's own if __name__ == "__main__" block
+	// has the correct launch parameters (show_error, etc.)
+	const childProcess = spawn("python", [demoFilePath], {
+		stdio: "pipe",
+		cwd: ROOT_DIR,
+		env: {
+			...process.env,
+			PYTHONUNBUFFERED: "true",
+			GRADIO_ANALYTICS_ENABLED: "False",
+			GRADIO_IS_E2E_TEST: "1",
+			GRADIO_RESET_EXAMPLES_CACHE: "True",
+			// Control the port via environment variable
+			GRADIO_SERVER_PORT: port.toString(),
+			// Use unique directories per instance to avoid conflicts
+			GRADIO_EXAMPLES_CACHE: cacheDir,
+			GRADIO_TEMP_DIR: tempDir
+		}
+	});
+
+	childProcess.stdout?.setEncoding("utf8");
+	childProcess.stderr?.setEncoding("utf8");
+
+	// Wait for app to be ready
+	return new Promise<GradioApp>((resolve, reject) => {
+		const timeoutId = setTimeout(() => {
+			killGradioApp(childProcess);
+			reject(
+				new Error(`Gradio app ${demoName} failed to start within ${timeout}ms`)
+			);
+		}, timeout);
+
+		let output = "";
+
+		function handleOutput(data: string): void {
+			output += data;
+			// Check for Gradio's startup message
+			if (
+				data.includes("Running on local URL:") ||
+				data.includes(`Uvicorn running on`)
+			) {
+				clearTimeout(timeoutId);
+				resolve({ port, process: childProcess });
+			}
+		}
+
+		childProcess.stdout?.on("data", handleOutput);
+		childProcess.stderr?.on("data", handleOutput);
+
+		childProcess.on("error", (err) => {
+			clearTimeout(timeoutId);
+			reject(err);
+		});
+
+		childProcess.on("exit", (code) => {
+			if (code !== 0 && code !== null) {
+				clearTimeout(timeoutId);
+				reject(
+					new Error(
+						`Gradio app ${demoName} exited with code ${code}.\nOutput: ${output}`
+					)
+				);
+			}
+		});
+	});
+}

6.4.0/tootils/src/index.ts

@@ -1,13 +1,15 @@
 import { test as base, type Locator, type Page } from "@playwright/test";
 import { spy } from "tinyspy";
-import { performance } from "node:perf_hooks";
 import url from "url";
 import path from "path";
 import fsPromises from "fs/promises";
+import type { ChildProcess } from "node:child_process";
 
 import type { SvelteComponent } from "svelte";
 import type { SpyFn } from "tinyspy";
 
+import { launchGradioApp, killGradioApp, hasTestcase } from "./app-launcher";
+
 export function get_text<T extends HTMLElement>(el: T): string {
 	return el.innerText.trim();
 }
@@ -21,30 +23,125 @@ const ROOT_DIR = path.resolve(
 	"../../../.."
 );
 
+// Extract testcase name from test title if present
+// Test titles can be:
+//   - "case eager_caching_examples: ..."
+//   - "test case multimodal_messages chatinterface works..."
+function extractTestcaseFromTitle(
+	title: string,
+	demoName: string
+): string | undefined {
+	// Try pattern: "case <name>:" or "test case <name> "
+	const patterns = [/^case\s+(\w+):/, /^test case\s+(\w+)\s/];
+
+	for (const pattern of patterns) {
+		const match = title.match(pattern);
+		if (match) {
+			const caseName = match[1];
+			// Check if this is a testcase (not the main demo)
+			if (hasTestcase(demoName, caseName)) {
+				return caseName;
+			}
+		}
+	}
+	return undefined;
+}
+
+// Cache for launched apps - key is "demoName" or "demoName_testcaseName"
+const appCache = new Map<
+	string,
+	{ port: number; process: ChildProcess; refCount: number }
+>();
+
+// Test fixture that launches Gradio app per test
 const test_normal = base.extend<{ setup: void }>({
 	setup: [
 		async ({ page }, use, testInfo): Promise<void> => {
-			const port = process.env.GRADIO_E2E_TEST_PORT;
-			const { file } = testInfo;
-			const test_name = path.basename(file, ".spec.ts");
+			const { file, title } = testInfo;
+			const demoName = path.basename(file, ".spec.ts");
+
+			// Check if this is a reload test (they manage their own apps)
+			if (demoName.endsWith(".reload")) {
+				// For reload tests, don't launch an app - they handle it themselves
+				await use();
+				return;
+			}
+
+			// Check if this test is for a specific testcase
+			const testcaseName = extractTestcaseFromTitle(title, demoName);
+
+			// Cache key includes testcase if present
+			const cacheKey = testcaseName ? `${demoName}_${testcaseName}` : demoName;
+
+			let appInfo = appCache.get(cacheKey);
+
+			if (!appInfo) {
+				// Launch the app for this test
+				const workerIndex = testInfo.workerIndex;
+				try {
+					const { port, process } = await launchGradioApp(
+						demoName,
+						workerIndex,
+						60000,
+						testcaseName
+					);
+					appInfo = { port, process, refCount: 0 };
+					appCache.set(cacheKey, appInfo);
+				} catch (error) {
+					console.error(`Failed to launch app for ${cacheKey}:`, error);
+					throw error;
+				}
+			}
+
+			appInfo.refCount++;
+
+			// Navigate to the app
+			await page.goto(`http://localhost:${appInfo.port}`);
 
-			await page.goto(`localhost:${port}/${test_name}`);
 			if (
 				process.env?.GRADIO_SSR_MODE?.toLowerCase() === "true" &&
 				!(
-					test_name.includes("multipage") ||
-					test_name.includes("chatinterface_deep_link")
+					demoName.includes("multipage") ||
+					demoName.includes("chatinterface_deep_link")
 				)
 			) {
 				await page.waitForSelector("#svelte-announcer");
 			}
 			await page.waitForLoadState("load");
+
 			await use();
+
+			// Decrement ref count
+			appInfo.refCount--;
+
+			// Note: We don't kill the app here because other tests might
+			// still need it. The app will be killed when the process exits.
 		},
 		{ auto: true }
 	]
 });
 
+// Cleanup apps when the process exits
+process.on("exit", () => {
+	for (const [, appInfo] of appCache) {
+		killGradioApp(appInfo.process);
+	}
+});
+
+process.on("SIGINT", () => {
+	for (const [, appInfo] of appCache) {
+		killGradioApp(appInfo.process);
+	}
+	process.exit(0);
+});
+
+process.on("SIGTERM", () => {
+	for (const [, appInfo] of appCache) {
+		killGradioApp(appInfo.process);
+	}
+	process.exit(0);
+});
+
 export const test = test_normal;
 
 export async function wait_for_event(
@@ -119,11 +216,10 @@ export const drag_and_drop_file = async (
 
 export async function go_to_testcase(
 	page: Page,
-	test_case: string
+	_test_case: string
 ): Promise<void> {
-	const url = page.url();
-	await page.goto(`${url.substring(0, url.length - 1)}_${test_case}_testcase`);
-	if (process.env?.GRADIO_SSR_MODE?.toLowerCase() === "true") {
-		await page.waitForSelector("#svelte-announcer");
-	}
+	// With the new setup, each testcase launches its own Gradio app.
+	// The fixture detects the testcase from the test title and launches
+	// the correct app, so this function is now a no-op.
+	// The page is already at the correct testcase app.
 }