Upload folder using huggingface_hub

6.14.1/tootils/package.json

@@ -0,0 +1,27 @@
+{
+	"name": "@self/tootils",
+	"version": "0.14.0",
+	"description": "Internal test utilities",
+	"type": "module",
+	"main": "src/index.ts",
+	"author": "",
+	"license": "ISC",
+	"private": true,
+	"dependencies": {
+		"@gradio/statustracker": "workspace:^",
+		"@gradio/utils": "workspace:^"
+	},
+	"peerDependencies": {
+		"svelte": "^5.48.0"
+	},
+	"exports": {
+		".": "./src/index.ts",
+		"./render": "./src/render.ts",
+		"./shared-prop-tests": "./src/shared-prop-tests.ts",
+		"./app-launcher": "./src/app-launcher.ts",
+		"./download-command": "./src/download-command.ts"
+	},
+	"scripts": {
+		"package": "svelte-package --input=. --tsconfig=../../tsconfig.json"
+	}
+}

6.14.1/tootils/src/app-launcher.ts

@@ -0,0 +1,276 @@
+import { spawn, spawnSync, type ChildProcess } from "node:child_process";
+import http from "http";
+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
+	}
+}
+
+/**
+ * Sweep orphaned gradio demo python processes — i.e. processes running
+ * `python <demo>/run.py` whose parent has died (PPID == 1, reparented to
+ * init/launchd). Without this, a Playwright worker that crashes (e.g.
+ * after a test timeout) leaves its spawned demo apps behind: the new
+ * worker has an empty appCache and won't kill them, ports get squatted,
+ * and resources accumulate. Documented behavior, not a guess: in the SSR
+ * profile run, this orphaning produced 100+ leaked python procs / 7.5GB.
+ *
+ * Best-effort: failures in the sweep are swallowed so they can't block
+ * the spawn path itself.
+ */
+function reapOrphanedDemos(): void {
+	try {
+		const result = spawnSync("ps", ["-A", "-o", "pid=,ppid=,command="], {
+			encoding: "utf8"
+		});
+		if (result.status !== 0 || !result.stdout) return;
+
+		for (const line of result.stdout.split("\n")) {
+			const trimmed = line.trim();
+			if (!trimmed) continue;
+			const match = trimmed.match(/^(\d+)\s+(\d+)\s+(.*)$/);
+			if (!match) continue;
+			const [, pidStr, ppidStr, cmd] = match;
+			if (ppidStr !== "1") continue;
+			// Only target our test demo apps (python running gradio demo files).
+			// Match `gradio/.../demo/<name>/<file>.py` to avoid accidentally
+			// killing unrelated python processes.
+			if (!/python.*\/demo\/[^/]+\/[^/]+\.py/.test(cmd)) continue;
+			if (!cmd.includes("/gradio/")) continue;
+			try {
+				process.kill(Number(pidStr), "SIGTERM");
+			} catch {
+				// already dead, or not ours to kill
+			}
+		}
+	} catch {
+		// ps unavailable or parse error — non-fatal
+	}
+}
+
+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) => {
+		const sock = net.createConnection(port, "127.0.0.1");
+		sock.once("connect", () => {
+			sock.end();
+			resolve(false);
+		});
+		sock.once("error", (e: NodeJS.ErrnoException) => {
+			sock.destroy();
+			// ECONNREFUSED → no listener (free). Anything else (ECONNRESET from
+			// a half-closed socket left by a SIGTERM'd demo, ETIMEDOUT, etc.)
+			// → don't trust the port, skip to the next one. Previously we
+			// rejected on non-ECONNREFUSED errors, which aborted the whole
+			// findFreePort scan and surfaced as "Failed to launch app".
+			resolve(e.code === "ECONNREFUSED");
+		});
+	});
+}
+
+/**
+ * Poll the server with HTTP GET requests until it returns a response.
+ * Gradio prints "Running on local URL:" before the server is fully ready,
+ * so we need to verify it actually responds to HTTP requests.
+ */
+async function waitForServerReady(
+	port: number,
+	timeoutMs: number = 15000
+): Promise<void> {
+	const start = Date.now();
+	const pollInterval = 200;
+
+	while (Date.now() - start < timeoutMs) {
+		try {
+			await new Promise<void>((resolve, reject) => {
+				// Use HEAD on /gradio_api/info to avoid triggering SSR rendering on
+				// the root URL, which could block Gradio's own startup health check.
+				const req = http.request(
+					`http://127.0.0.1:${port}/gradio_api/info`,
+					{ method: "HEAD", timeout: 2000 },
+					(res) => {
+						res.resume(); // drain the response
+						resolve();
+					}
+				);
+				req.on("error", reject);
+				req.on("timeout", () => {
+					req.destroy();
+					reject(new Error("request timeout"));
+				});
+				req.end();
+			});
+			return; // Server responded successfully
+		} catch {
+			// Server not ready yet, wait and retry
+			await new Promise((r) => setTimeout(r, pollInterval));
+		}
+	}
+	throw new Error(
+		`Server on port ${port} did not become ready within ${timeoutMs}ms`
+	);
+}
+
+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> {
+	// Sweep orphaned demo apps from previous (crashed) worker generations
+	// before claiming a port — see reapOrphanedDemos() for rationale.
+	reapOrphanedDemos();
+
+	// 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 via _demo_runner.py instead of directly. The wrapper
+	// watches its stdin pipe: if the playwright worker that spawned us
+	// dies (cleanly or via SIGKILL on timeout), the kernel closes the pipe,
+	// stdin returns EOF and the demo self-exits immediately — instead of
+	// becoming an orphan that survives the rest of the suite.
+	const demoRunnerPath = path.join(__dirname, "_demo_runner.py");
+	const childProcess = spawn("python", [demoRunnerPath, 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 = "";
+		let startupDetected = false;
+
+		function handleOutput(data: string): void {
+			output += data;
+			// Check for Gradio's startup message
+			if (
+				!startupDetected &&
+				(data.includes("Running on local URL:") ||
+					data.includes(`Uvicorn running on`))
+			) {
+				startupDetected = true;
+				clearTimeout(timeoutId);
+				// The startup message is printed before the server is fully ready.
+				// Poll with HTTP requests to ensure it actually responds.
+				waitForServerReady(port)
+					.then(() => resolve({ port, process: childProcess }))
+					.catch(reject);
+			}
+		}
+
+		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.14.1/tootils/src/download-command.ts

@@ -0,0 +1,136 @@
+import type { BrowserCommand } from "vitest/node";
+import { resolve } from "path";
+import { readFile } from "fs/promises";
+
+/**
+ * Vitest browser command that captures a real file download triggered by
+ * clicking an element. Runs server-side with access to the Playwright page.
+ *
+ * Sets up page.waitForEvent("download") BEFORE clicking, so the download
+ * event is never missed.
+ */
+export const expect_download: BrowserCommand<
+	[selector: string, options?: { timeout?: number }],
+	{ suggested_filename: string; content: string | null }
+> = async (context, selector, options) => {
+	const timeout = options?.timeout ?? 5000;
+	const provider = context.provider as any;
+	const page = provider.getPage(context.sessionId);
+	// Tests run inside an iframe; use the iframe locator to click
+	// but listen for the download event on the parent page.
+	const iframe = (context as any).iframe;
+
+	const [download] = await Promise.all([
+		page.waitForEvent("download", { timeout }),
+		iframe.locator(selector).click()
+	]);
+
+	const suggested_filename = download.suggestedFilename();
+	const path = await download.path();
+
+	let content: string | null = null;
+	if (path) {
+		const fs = await import("fs/promises");
+		content = await fs.readFile(path, "utf-8");
+	}
+
+	return {
+		suggested_filename,
+		content
+	};
+};
+
+/**
+ * Vitest browser command that sets files on an <input type="file"> element.
+ * Resolves fixture URL paths (e.g. "/test/test_files/bus.png") to absolute
+ * disk paths and uses Playwright's setInputFiles().
+ */
+export const set_file_inputs: BrowserCommand<
+	[file_urls: string[], selector?: string]
+> = async (context, file_urls, selector) => {
+	const root = context.project.config.root;
+	const iframe = (context as any).iframe;
+
+	const paths = file_urls.map((url) => resolve(root, url.replace(/^\//, "")));
+
+	await iframe
+		.locator(selector ?? 'input[type="file"]')
+		.first()
+		.setInputFiles(paths);
+};
+
+interface Drop_file_spec {
+	data: string; // base64
+	name: string;
+	mime_type: string;
+}
+
+/**
+ * Vitest browser command that simulates dropping files onto an element.
+ * Reads files from disk, transfers them as base64 into the browser context,
+ * and dispatches dragenter, dragover, and drop events with a real DataTransfer.
+ */
+export const drop_files: BrowserCommand<
+	[file_urls: string[], selector: string]
+> = async (context, file_urls, selector) => {
+	const root = context.project.config.root;
+
+	const files: Drop_file_spec[] = await Promise.all(
+		file_urls.map(async (url) => {
+			const abs = resolve(root, url.replace(/^\//, ""));
+			const data = (await readFile(abs)).toString("base64");
+			const name = abs.split("/").pop()!;
+			const ext = name.split(".").pop()!.toLowerCase();
+			const mime_type = MIME_TYPES[ext] || "application/octet-stream";
+			return { data, name, mime_type };
+		})
+	);
+
+	const iframe = (context as any).iframe;
+	await iframe
+		.locator(selector)
+		.first()
+		.evaluate((target: Element, files: Drop_file_spec[]) => {
+			const dt = new DataTransfer();
+			for (const f of files) {
+				const bytes = Uint8Array.from(atob(f.data), (c) => c.charCodeAt(0));
+				dt.items.add(new File([bytes], f.name, { type: f.mime_type }));
+			}
+
+			target.dispatchEvent(
+				new DragEvent("dragenter", {
+					dataTransfer: dt,
+					bubbles: true
+				})
+			);
+			target.dispatchEvent(
+				new DragEvent("dragover", {
+					dataTransfer: dt,
+					bubbles: true
+				})
+			);
+			target.dispatchEvent(
+				new DragEvent("drop", { dataTransfer: dt, bubbles: true })
+			);
+		}, files);
+};
+
+const MIME_TYPES: Record<string, string> = {
+	txt: "text/plain",
+	csv: "text/csv",
+	json: "application/json",
+	pdf: "application/pdf",
+	jpg: "image/jpeg",
+	jpeg: "image/jpeg",
+	png: "image/png",
+	gif: "image/gif",
+	webp: "image/webp",
+	svg: "image/svg+xml",
+	mp4: "video/mp4",
+	webm: "video/webm",
+	ogg: "video/ogg",
+	avi: "video/x-msvideo",
+	wav: "audio/wav",
+	mp3: "audio/mpeg",
+	flac: "audio/flac"
+};

6.14.1/tootils/src/download.ts

@@ -0,0 +1,92 @@
+import { commands } from "vitest/browser";
+import type { FileData } from "@gradio/client";
+
+export interface DownloadResult {
+	suggested_filename: string;
+	content: string | null;
+}
+
+/**
+ * Clicks an element and captures the resulting file download.
+ *
+ * Uses a real browser download via Playwright under the hood —
+ * the file is actually downloaded and its content is readable.
+ *
+ * @param selector - CSS selector for the element to click
+ * @param options - Optional timeout (default 5000ms)
+ * @returns The downloaded file's suggested filename and text content
+ *
+ * @example
+ * ```ts
+ * const { suggested_filename, content } = await download_file("a.download-link");
+ * expect(suggested_filename).toBe("data.csv");
+ * expect(content).toContain("col1,col2");
+ * ```
+ */
+export async function download_file(
+	selector: string,
+	options?: { timeout?: number }
+): Promise<DownloadResult> {
+	return (commands as any).expect_download(selector, options);
+}
+
+/**
+ * Sets files on an `<input type="file">` element using real file fixtures.
+ *
+ * Accepts one or more FileData fixtures (e.g. TEST_JPG, TEST_PNG) and
+ * sets them on the file input, triggering the browser's native change event.
+ *
+ * @param files - One or more FileData fixtures to upload
+ * @param selector - CSS selector for the file input (default: 'input[type="file"]')
+ *
+ * @example
+ * ```ts
+ * import { render, upload_file, TEST_JPG } from "@self/tootils/render";
+ *
+ * const { listen } = await render(ImageUpload, { interactive: true });
+ * const upload = listen("upload");
+ *
+ * await upload_file(TEST_JPG);
+ *
+ * expect(upload).toHaveBeenCalled();
+ * ```
+ */
+export async function upload_file(
+	files: FileData | FileData[],
+	selector?: string
+): Promise<void> {
+	const file_list = Array.isArray(files) ? files : [files];
+	const urls = file_list.map((f) => f.url ?? f.path);
+	return (commands as any).set_file_inputs(urls, selector);
+}
+
+/**
+ * Simulates dragging and dropping files onto an element.
+ *
+ * Reads the fixture files from disk, constructs a real DataTransfer
+ * with File objects, and dispatches dragenter, dragover, and drop events
+ * on the target element.
+ *
+ * @param files - One or more FileData fixtures to drop
+ * @param selector - CSS selector for the drop target element
+ *
+ * @example
+ * ```ts
+ * import { render, drop_file, TEST_JPG } from "@self/tootils/render";
+ *
+ * const { listen } = await render(ImageUpload, { interactive: true });
+ * const upload = listen("upload");
+ *
+ * await drop_file(TEST_JPG, "[aria-label='Click to upload or drop files']");
+ *
+ * await vi.waitFor(() => expect(upload).toHaveBeenCalled());
+ * ```
+ */
+export async function drop_file(
+	files: FileData | FileData[],
+	selector: string
+): Promise<void> {
+	const file_list = Array.isArray(files) ? files : [files];
+	const urls = file_list.map((f) => f.url ?? f.path);
+	return (commands as any).drop_files(urls, selector);
+}

6.14.1/tootils/src/fixtures.ts

@@ -0,0 +1,28 @@
+import { FileData } from "@gradio/client";
+
+const BASE = "/test/test_files";
+
+function fixture(filename: string, mime_type: string, size: number): FileData {
+	const url = `${BASE}/${filename}`;
+	return new FileData({
+		path: url,
+		url,
+		orig_name: filename,
+		size,
+		mime_type
+	});
+}
+
+export const TEST_TXT = fixture("alphabet.txt", "text/plain", 26);
+export const TEST_JPG = fixture("cheetah1.jpg", "image/jpeg", 20552);
+export const TEST_PNG = fixture("bus.png", "image/png", 1951);
+export const TEST_MP4 = fixture("video_sample.mp4", "video/mp4", 261179);
+export const TEST_WAV = fixture("audio_sample.wav", "audio/wav", 16136);
+export const TEST_PDF = fixture("sample_file.pdf", "application/pdf", 10558);
+export const TEST_GLTF = fixture("Box.gltf", "model/gltf+json", 5249);
+export const TEST_PLY = fixture("model.ply", "application/octet-stream", 413);
+export const TEST_SPLAT = fixture(
+	"model.splat",
+	"application/octet-stream",
+	32
+);

6.14.1/tootils/src/index.ts

@@ -0,0 +1,245 @@
+import { test as base, type Locator, type Page } from "@playwright/test";
+import { spy } from "tinyspy";
+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();
+}
+
+export function wait(n: number): Promise<void> {
+	return new Promise((r) => setTimeout(r, n));
+}
+
+const ROOT_DIR = path.resolve(
+	url.fileURLToPath(import.meta.url),
+	"../../../.."
+);
+
+// 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 }
+>();
+
+// Track the cacheKey of the currently-running spec file so we can kill the
+// previous spec's gradio app when the worker moves on. Without this, every
+// app spawned during a worker's lifetime stayed resident until process exit
+// (~50 python procs / 5GB RSS by end of suite — the tail of the run starved
+// for CPU and tests timed out).
+let currentCacheKey: string | null = null;
+
+function killAndEvict(cacheKey: string): void {
+	const info = appCache.get(cacheKey);
+	if (!info) return;
+	killGradioApp(info.process);
+	appCache.delete(cacheKey);
+}
+
+// Test fixture that launches Gradio app per test
+const test_normal = base.extend<{ setup: void }>({
+	setup: [
+		async ({ page }, use, testInfo): Promise<void> => {
+			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;
+
+			// First test of a new spec file → previous file's app is no longer
+			// needed on this worker. fullyParallel=false in playwright.config
+			// guarantees a worker finishes a file before starting the next, so
+			// the kill is unconditional on the transition (we don't gate on
+			// refCount: a throw before `await use()` — e.g. a flaky SSR
+			// hydration wait — can leak refCount, which would otherwise pin
+			// the previous spec's app forever).
+			if (currentCacheKey !== null && currentCacheKey !== cacheKey) {
+				killAndEvict(currentCacheKey);
+			}
+			currentCacheKey = cacheKey;
+
+			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;
+				}
+			}
+
+			try {
+				// Navigate to the app
+				await page.goto(`http://localhost:${appInfo.port}`);
+
+				if (
+					process.env?.GRADIO_SSR_MODE?.toLowerCase() === "true" &&
+					!(
+						demoName.includes("multipage") ||
+						demoName.includes("chatinterface_deep_link")
+					)
+				) {
+					await page.waitForSelector("#svelte-announcer");
+				}
+				await page.waitForLoadState("load");
+
+				await use();
+			} finally {
+			}
+		},
+		{ 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(
+	component: SvelteComponent,
+	event: string
+): Promise<SpyFn> {
+	const mock = spy();
+	return new Promise((res) => {
+		component.$on(event, () => {
+			mock();
+			res(mock);
+		});
+	});
+}
+
+export interface ActionReturn<
+	Parameter = never,
+	Attributes extends Record<string, any> = Record<never, any>
+> {
+	update?: [Parameter] extends [never] ? never : (parameter: Parameter) => void;
+	destroy?: () => void;
+	/**
+	 * ### DO NOT USE THIS
+	 * This exists solely for type-checking and has no effect at runtime.
+	 * Set this through the `Attributes` generic instead.
+	 */
+	$$_attributes?: Attributes;
+}
+
+export { expect } from "@playwright/test";
+
+export const drag_and_drop_file = async (
+	page: Page,
+	selector: string | Locator,
+	filePath: string,
+	fileName: string,
+	fileType = "",
+	count = 1
+): Promise<void> => {
+	const buffer = (await fsPromises.readFile(filePath)).toString("base64");
+
+	const dataTransfer = await page.evaluateHandle(
+		async ({ bufferData, localFileName, localFileType, count }) => {
+			const dt = new DataTransfer();
+
+			const blobData = await fetch(bufferData).then((res) => res.blob());
+
+			const file = new File([blobData], localFileName, {
+				type: localFileType
+			});
+
+			for (let i = 0; i < count; i++) {
+				dt.items.add(file);
+			}
+			return dt;
+		},
+		{
+			bufferData: `data:application/octet-stream;base64,${buffer}`,
+			localFileName: fileName,
+			localFileType: fileType,
+			count
+		}
+	);
+
+	if (typeof selector === "string") {
+		await page.dispatchEvent(selector, "drop", { dataTransfer });
+	} else {
+		await selector.dispatchEvent("drop", { dataTransfer });
+	}
+};
+
+export async function go_to_testcase(
+	page: Page,
+	_test_case: string
+): Promise<void> {
+	// 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.
+}

6.14.1/tootils/src/render.ts

@@ -0,0 +1,317 @@
+import {
+	getQueriesForElement,
+	prettyDOM,
+	fireEvent as dtlFireEvent
+} from "@testing-library/dom";
+import { tick, mount, unmount } from "svelte";
+import type { SvelteComponent, Component } from "svelte";
+
+import type {
+	queries,
+	Queries,
+	BoundFunction,
+	EventType
+} from "@testing-library/dom";
+import { vi, type Mock } from "vitest";
+import { GRADIO_ROOT, allowed_shared_props } from "@gradio/utils";
+import type { LoadingStatus, ILoadingStatus } from "@gradio/statustracker";
+import { _ } from "svelte-i18n";
+
+const containerCache = new Map();
+const componentCache = new Set();
+
+type ComponentType<T extends SvelteComponent, Props> = Component<Props>;
+
+export type RenderResult<
+	C extends SvelteComponent,
+	Q extends Queries = typeof queries
+> = {
+	container: HTMLElement;
+	component: C;
+	debug: (el?: HTMLElement | DocumentFragment) => void;
+	unmount: () => void;
+} & { [P in keyof Q]: BoundFunction<Q[P]> };
+export interface ILoadingStatus {
+	eta: number | null;
+	status: "pending" | "error" | "complete" | "generating" | "streaming";
+	queue: boolean;
+	queue_position: number | null;
+	queue_size?: number;
+	fn_index: number;
+	message?: string | null;
+	scroll_to_output?: boolean;
+	show_progress?: "full" | "minimal" | "hidden";
+	time_limit?: number | null | undefined;
+	progress?: {
+		progress: number | null;
+		index: number | null;
+		length: number | null;
+		unit: string | null;
+		desc: string | null;
+	}[];
+	validation_error?: string | null;
+	type: "input" | "output";
+	stream_state: "open" | "closed" | "waiting" | null;
+}
+
+const loading_status: ILoadingStatus = {
+	eta: 0,
+	queue_position: 1,
+	queue_size: 1,
+	queue: true,
+	message: null,
+	time_limit: null,
+	progress: [],
+	validation_error: null,
+	type: "output",
+	stream_state: null,
+	status: "complete" as ILoadingStatus["status"],
+	scroll_to_output: false,
+	fn_index: 0,
+	show_progress: "full" as ILoadingStatus["show_progress"]
+};
+
+export interface RenderOptions<Q extends Queries = typeof queries> {
+	container?: HTMLElement;
+	queries?: Q;
+}
+
+export async function render<
+	Events extends Record<string, any>,
+	Props extends Record<string, any>,
+	T extends SvelteComponent<Props, Events>,
+	X extends Record<string, any>
+>(
+	Component: ComponentType<T, Props> | { default: ComponentType<T, Props> },
+	props?: Omit<Props, "gradio" | "loading_status"> & {
+		loading_status?: LoadingStatus;
+	},
+	options?: {
+		container?: HTMLElement;
+	}
+): Promise<
+	RenderResult<T> & {
+		listen: (event_name: string, opts?: { retrospective?: boolean }) => Mock;
+		set_data: (data: Record<string, any>) => Promise<void>;
+		get_data: () => Promise<Record<string, any>>;
+	}
+> {
+	let container: HTMLElement;
+	if (!options?.container) {
+		container = document.body;
+	} else {
+		container = options.container;
+	}
+
+	const target = container.appendChild(document.createElement("div"));
+
+	const ComponentConstructor: ComponentType<T, Props> =
+		//@ts-ignore
+		Component.default || Component;
+
+	const id = Math.floor(Math.random() * 1000000);
+
+	let component_set_data: (data: Record<string, any>) => void;
+	let component_get_data: () => Promise<Record<string, any>>;
+
+	const mock_register = (
+		_id: number,
+		set_data: (data: Record<string, any>) => void,
+		get_data: () => Promise<Record<string, any>>
+	): void => {
+		component_set_data = set_data;
+		component_get_data = get_data;
+	};
+
+	const event_listeners = new Map<string, Set<(data: any) => void>>();
+	const event_buffer: Array<{ event: string; data: any }> = [];
+
+	function notify_listeners(event: string, data: any): void {
+		const listeners = event_listeners.get(event);
+		if (listeners) {
+			for (const listener of listeners) {
+				listener(data);
+			}
+		}
+	}
+
+	const dispatcher = (_id: number, event: string, data: any): void => {
+		event_buffer.push({ event, data });
+		notify_listeners(event, data);
+	};
+
+	function listen(
+		event_name: string,
+		opts?: { retrospective?: boolean }
+	): Mock {
+		const fn = vi.fn();
+		if (!event_listeners.has(event_name)) {
+			event_listeners.set(event_name, new Set());
+		}
+		event_listeners.get(event_name)!.add(fn);
+
+		if (opts?.retrospective) {
+			for (const entry of event_buffer) {
+				if (entry.event === event_name) {
+					fn(entry.data);
+				}
+			}
+		}
+
+		return fn;
+	}
+
+	const i18nFormatter = (s: string | null | undefined): string => s ?? "";
+
+	const shared_props_obj: Record<string, any> = {
+		id,
+		target,
+		theme_mode: "light" as const,
+		version: "2.0.0",
+		formatter: i18nFormatter,
+		client: {} as any,
+		load_component: () => Promise.resolve({ default: {} as any }),
+		show_progress: true,
+		api_prefix: "",
+		server: {} as any,
+		show_label: true,
+		register_component: mock_register,
+		dispatcher
+	};
+
+	const component_props_obj: Record<string, any> = {
+		i18n: i18nFormatter
+	};
+
+	if (props) {
+		for (const key in props) {
+			const value = (props as any)[key];
+			if (allowed_shared_props.includes(key as any)) {
+				shared_props_obj[key] = value;
+			} else {
+				component_props_obj[key] = value;
+			}
+		}
+	}
+
+	shared_props_obj.loading_status = props?.loading_status
+		? props.loading_status
+		: loading_status;
+
+	const componentProps = {
+		shared_props: shared_props_obj,
+		props: {
+			...component_props_obj
+		},
+		...shared_props_obj
+	};
+
+	const component = mount(ComponentConstructor, {
+		target,
+		props: componentProps
+	}) as T;
+
+	containerCache.set(container, { target, component });
+	componentCache.add(component);
+
+	await tick();
+
+	return {
+		container,
+		component,
+		listen,
+		set_data: async (data: Record<string, any>) => {
+			const r = component_set_data(data);
+			// we double tick here because the event may trigger state update inside  the component
+			// the event may _only_ be fired in response to these state updates.
+			// so we want everything to settle before returning and continuing with the test.
+			await tick();
+			await tick();
+			return r;
+		},
+		get_data: () => component_get_data(),
+		//@ts-ignore
+		debug: (el = container): void => console.warn(prettyDOM(el)),
+		unmount: (): void => {
+			if (componentCache.has(component)) {
+				unmount(component);
+			}
+		},
+		...getQueriesForElement(container)
+	};
+}
+
+const cleanupAtContainer = (container: HTMLElement): void => {
+	const { target, component } = containerCache.get(container);
+
+	if (componentCache.has(component)) {
+		unmount(component);
+	}
+
+	if (target.parentNode === document.body) {
+		document.body.removeChild(target);
+	}
+
+	containerCache.delete(container);
+};
+
+export function cleanup(): void {
+	Array.from(containerCache.keys()).forEach(cleanupAtContainer);
+	document.body.innerHTML = "";
+}
+
+type AsyncFireObject = {
+	[K in EventType]: (
+		element: Document | Element | Window | Node,
+		options?: object
+	) => Promise<boolean>;
+};
+
+export const fireEvent = Object.keys(dtlFireEvent).reduce((acc, key) => {
+	const _key = key as EventType;
+	return {
+		...acc,
+		[_key]: async (
+			element: Document | Element | Window,
+			options: object = {}
+		): Promise<boolean> => {
+			const event = dtlFireEvent[_key](element, options);
+			// we double tick here because the event may trigger state update inside  the component
+			// the event may _only_ be fired in response to these state updates.
+			// so we want everything to settle before returning and continuing with the test.
+			await tick();
+			await tick();
+			return event;
+		}
+	};
+}, {} as AsyncFireObject);
+
+export type FireFunction = (
+	element: Document | Element | Window,
+	event: Event
+) => Promise<boolean>;
+
+export { download_file, upload_file, drop_file } from "./download.js";
+
+/**
+ * Creates a mock client suitable for components that use file uploads.
+ * The upload mock echoes back the input FileData unchanged.
+ */
+export function mock_client(): Record<string, any> {
+	return {
+		upload: async (file_data: any[]) => file_data,
+		stream: async () => ({ onmessage: null, close: () => {} })
+	};
+}
+export {
+	TEST_TXT,
+	TEST_JPG,
+	TEST_PNG,
+	TEST_MP4,
+	TEST_WAV,
+	TEST_PDF,
+	TEST_GLTF,
+	TEST_PLY,
+	TEST_SPLAT
+} from "./fixtures.js";
+export * from "@testing-library/dom";

6.14.1/tootils/src/shared-prop-tests.ts

@@ -0,0 +1,183 @@
+import { describe, test, expect, afterEach } from "vitest";
+import { render, cleanup } from "./render";
+
+const loading_status = {
+	status: "complete",
+	queue_position: null,
+	queue_size: null,
+	eta: null,
+	message: null
+};
+
+export interface SharedPropTestConfig {
+	/** The Svelte component to test */
+	component: any;
+	/** Minimum props required to render the component without errors */
+	base_props: Record<string, any>;
+	/** Display name for test output */
+	name: string;
+	/**
+	 * Some components don't render labels (e.g. HTML, Markdown).
+	 * Set to false to skip label-related tests.
+	 * @default true
+	 */
+	has_label?: boolean;
+	/**
+	 * Whether the component renders validation_error text.
+	 * Not all components support this. Set to false to skip.
+	 * @default true
+	 */
+	has_validation_error?: boolean;
+	/**
+	 * Some components (e.g. Accordion) map visible=false to "hidden"
+	 * instead of removing from the DOM. Set to true to expect hidden
+	 * behaviour rather than removal.
+	 * @default false
+	 */
+	visible_false_hides?: boolean;
+	/**
+	 * Whether the component is wrapped in a Block (which renders a `.block`
+	 * element). Components like Button render a bare element instead.
+	 * Set to false to skip `.block` selector checks.
+	 * @default true
+	 */
+	has_block_wrapper?: boolean;
+}
+
+export function run_shared_prop_tests(config: SharedPropTestConfig): void {
+	const {
+		component,
+		base_props,
+		name,
+		has_label = true,
+		has_validation_error = true,
+		visible_false_hides = false,
+		has_block_wrapper = true
+	} = config;
+
+	const label = "Test Label";
+
+	function make_props(
+		overrides: Record<string, any> = {}
+	): Record<string, any> {
+		return {
+			...base_props,
+			loading_status: { ...loading_status, ...overrides },
+			label,
+			...overrides
+		};
+	}
+
+	describe(`${name}: shared props`, () => {
+		afterEach(() => cleanup());
+
+		test("elem_id is applied to the wrapper", async () => {
+			const { container } = await render(
+				component,
+				make_props({ elem_id: "my-test-id" })
+			);
+			const el = container.querySelector("#my-test-id");
+			expect(el).not.toBeNull();
+		});
+
+		test("elem_classes are applied to the wrapper", async () => {
+			const { container } = await render(
+				component,
+				make_props({ elem_classes: ["my-test-class"] })
+			);
+			const el = container.querySelector(".my-test-class");
+			expect(el).not.toBeNull();
+		});
+
+		test("visible: true renders the component", async () => {
+			const { container } = await render(
+				component,
+				make_props({ visible: true, elem_id: "visible-test" })
+			);
+			const el = has_block_wrapper
+				? container.querySelector(".block")
+				: container.querySelector("#visible-test");
+			expect(el).not.toBeNull();
+		});
+
+		test("visible: 'hidden' hides the component but keeps it in the DOM", async () => {
+			const result = await render(
+				component,
+				make_props({ visible: "hidden", elem_id: "hidden-test" })
+			);
+
+			const el = result.container.querySelector("#hidden-test");
+			expect(el).not.toBeNull();
+			expect(el).not.toBeVisible();
+		});
+
+		if (visible_false_hides) {
+			test("visible: false hides the component but keeps it in the DOM", async () => {
+				const result = await render(
+					component,
+					make_props({ visible: false, elem_id: "gone-test" })
+				);
+
+				const el = result.container.querySelector("#gone-test");
+				expect(el).not.toBeNull();
+				expect(el).not.toBeVisible();
+			});
+		} else {
+			test("visible: false removes the component from the DOM", async () => {
+				const result = await render(
+					component,
+					make_props({ visible: false, elem_id: "gone-test" })
+				);
+
+				const el = result.container.querySelector("#gone-test");
+				expect(el).toBeNull();
+			});
+		}
+
+		if (has_label) {
+			test("label text is rendered", async () => {
+				const result = await render(
+					component,
+					make_props({ label: "My Custom Label", show_label: true })
+				);
+				const el = result.getByText("My Custom Label");
+				expect(el).toBeTruthy();
+			});
+
+			test("show_label: true makes the label visible", async () => {
+				const result = await render(
+					component,
+					make_props({ label: "Visible Label", show_label: true })
+				);
+				const el = result.getByText("Visible Label");
+				expect(el).toBeVisible();
+			});
+
+			test("show_label: false hides the label visually but keeps it in the DOM", async () => {
+				const result = await render(
+					component,
+					make_props({ label: "Hidden Label", show_label: false })
+				);
+				const el = result.getByText("Hidden Label");
+				// The label remains in the DOM for screen readers via sr-only.
+				// sr-only uses clip/1px dimensions rather than display:none,
+				// so toBeVisible() won't catch it. We check the class directly.
+				expect(el.closest("[data-testid='block-info']")).toHaveClass("sr-only");
+			});
+		}
+
+		if (has_validation_error) {
+			test("validation_error displays error text visibly", async () => {
+				const result = await render(
+					component,
+					make_props({
+						validation_error: "This field is required",
+						show_validation_error: true
+					})
+				);
+				const el = result.getByText("This field is required");
+				expect(el).toBeVisible();
+			});
+		}
+	});
+}