Upload folder using huggingface_hub

6.5.0/tootils/package.json

@@ -0,0 +1,25 @@
+{
+	"name": "@self/tootils",
+	"version": "0.9.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",
+		"./app-launcher": "./src/app-launcher.ts"
+	},
+	"scripts": {
+		"package": "svelte-package --input=. --tsconfig=../../tsconfig.json"
+	}
+}

6.5.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.5.0/tootils/src/index.ts

@@ -0,0 +1,225 @@
+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 }
+>();
+
+// 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;
+
+			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}`);
+
+			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();
+
+			// 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(
+	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 * from "./render";
+
+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.5.0/tootils/src/render.ts

@@ -0,0 +1,234 @@
+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,
+	FireObject
+} from "@testing-library/dom";
+import { spy, type Spy } from "tinyspy";
+import { GRADIO_ROOT, allowed_shared_props } from "@gradio/utils";
+import type { LoadingStatus } from "@gradio/statustracker";
+import { get } from "svelte/store";
+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]> };
+
+const loading_status: LoadingStatus = {
+	eta: 0,
+	queue_position: 1,
+	queue_size: 1,
+	status: "complete" as LoadingStatus["status"],
+	scroll_to_output: false,
+	visible: true,
+	fn_index: 0,
+	show_progress: "full"
+};
+
+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;
+	},
+	_container?: HTMLElement
+): Promise<
+	RenderResult<T> & {
+		listen: typeof listen;
+		wait_for_event: typeof wait_for_event;
+	}
+> {
+	let container: HTMLElement;
+	if (!_container) {
+		container = document.body;
+	} else {
+		container = _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);
+
+	const mockRegister = (): void => {};
+
+	const mockDispatcher = (_id: number, event: string, data: any): void => {
+		const e = new CustomEvent("gradio", {
+			bubbles: true,
+			detail: { data, id: _id, event }
+		});
+		target.dispatchEvent(e);
+	};
+
+	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
+	};
+
+	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;
+			}
+		}
+	}
+
+	const componentProps = {
+		shared_props: shared_props_obj,
+		props: {
+			...component_props_obj
+		},
+		...shared_props_obj
+	};
+
+	const component = mount(ComponentConstructor, {
+		target,
+		props: componentProps,
+		context: new Map([
+			[GRADIO_ROOT, { register: mockRegister, dispatcher: mockDispatcher }]
+		])
+	}) as T;
+
+	containerCache.set(container, { target, component });
+	componentCache.add(component);
+
+	await tick();
+
+	type event_name = string;
+
+	function listen(event: event_name): Spy {
+		const mock = spy();
+		target.addEventListener("gradio", (e: Event) => {
+			if (isCustomEvent(e)) {
+				if (e.detail.event === event && e.detail.id === id) {
+					mock(e);
+				}
+			}
+		});
+
+		return mock;
+	}
+
+	async function wait_for_event(event: event_name): Promise<Spy> {
+		return new Promise((res) => {
+			const mock = spy();
+			target.addEventListener("gradio", (e: Event) => {
+				if (isCustomEvent(e)) {
+					if (e.detail.event === event && e.detail.id === id) {
+						mock(e);
+						res(mock);
+					}
+				}
+			});
+		});
+	}
+
+	return {
+		container,
+		component,
+		//@ts-ignore
+		debug: (el = container): void => console.warn(prettyDOM(el)),
+		unmount: (): void => {
+			if (componentCache.has(component)) {
+				unmount(component);
+			}
+		},
+		...getQueriesForElement(container),
+		listen,
+		wait_for_event
+	};
+}
+
+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);
+}
+
+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);
+			await tick();
+			return event;
+		}
+	};
+}, {} as FireObject);
+
+export type FireFunction = (
+	element: Document | Element | Window,
+	event: Event
+) => Promise<boolean>;
+
+export * from "@testing-library/dom";
+
+function isCustomEvent(event: Event): event is CustomEvent {
+	return "detail" in event;
+}