Upload folder using huggingface_hub

5.49.1/client/package.json

@@ -0,0 +1,54 @@
+{
+	"name": "@gradio/client",
+	"version": "1.19.1",
+	"description": "Gradio API client",
+	"type": "module",
+	"main": "dist/index.js",
+	"author": "",
+	"license": "ISC",
+	"exports": {
+		".": {
+			"gradio": "./src/index.ts",
+			"browser": "./dist/browser.js",
+			"import": "./dist/index.js",
+			"default": "./dist/index.js"
+		},
+		"./package.json": "./package.json",
+		"./browser.js": "./dist/browser.js"
+	},
+	"dependencies": {
+		"@types/eventsource": "^1.1.15",
+		"bufferutil": "^4.0.7",
+		"eventsource": "^2.0.2",
+		"fetch-event-stream": "^0.1.5",
+		"msw": "^2.2.1",
+		"semiver": "^1.1.0",
+		"textlinestream": "^1.1.1",
+		"typescript": "^5.0.0",
+		"ws": "^8.13.0"
+	},
+	"devDependencies": {
+		"@types/ws": "^8.5.10",
+		"esbuild": "^0.21.0"
+	},
+	"scripts": {
+		"bundle": "vite build --ssr",
+		"bundle:browser": "BROWSER_BUILD=true vite build",
+		"generate_types": "tsc",
+		"clean": "rm -rf dist",
+		"build": "pnpm clean && pnpm bundle && pnpm bundle:browser && pnpm generate_types",
+		"test": "pnpm test:client && pnpm test:client:node",
+		"test:client": "vitest run -c vite.config.js",
+		"test:client:node": "TEST_MODE=node vitest run -c vite.config.js",
+		"preview:browser": "vite dev --mode=preview"
+	},
+	"engines": {
+		"node": ">=18.0.0"
+	},
+	"main_changeset": true,
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "client/js"
+	}
+}

5.49.1/client/src/client.ts

@@ -0,0 +1,611 @@
+import type {
+	ApiData,
+	ApiInfo,
+	ClientOptions,
+	Config,
+	DuplicateOptions,
+	EndpointInfo,
+	JsApiData,
+	PredictReturn,
+	SpaceStatus,
+	Status,
+	UploadResponse,
+	client_return,
+	SubmitIterable,
+	GradioEvent
+} from "./types";
+import { view_api } from "./utils/view_api";
+import { upload_files } from "./utils/upload_files";
+import { upload, FileData } from "./upload";
+import { handle_blob } from "./utils/handle_blob";
+import { post_data } from "./utils/post_data";
+import { predict } from "./utils/predict";
+import { duplicate } from "./utils/duplicate";
+import { submit } from "./utils/submit";
+import { RE_SPACE_NAME, process_endpoint } from "./helpers/api_info";
+import {
+	map_names_to_ids,
+	resolve_cookies,
+	resolve_config,
+	get_jwt,
+	parse_and_set_cookies
+} from "./helpers/init_helpers";
+import { check_and_wake_space, check_space_status } from "./helpers/spaces";
+import { open_stream, readable_stream, close_stream } from "./utils/stream";
+import {
+	API_INFO_ERROR_MSG,
+	APP_ID_URL,
+	CONFIG_ERROR_MSG,
+	HEARTBEAT_URL,
+	COMPONENT_SERVER_URL
+} from "./constants";
+
+declare const BROWSER_BUILD: boolean;
+
+export class Client {
+	app_reference: string;
+	options: ClientOptions;
+	deep_link: string | null = null;
+
+	config: Config | undefined;
+	api_prefix = "";
+	api_info: ApiInfo<JsApiData> | undefined;
+	api_map: Record<string, number> = {};
+	session_hash: string = Math.random().toString(36).substring(2);
+	jwt: string | false = false;
+	last_status: Record<string, Status["stage"]> = {};
+
+	private cookies: string | null = null;
+
+	// streaming
+	stream_status = { open: false };
+	closed = false;
+	pending_stream_messages: Record<string, any[][]> = {};
+	pending_diff_streams: Record<string, any[][]> = {};
+	event_callbacks: Record<string, (data?: unknown) => Promise<void>> = {};
+	unclosed_events: Set<string> = new Set();
+	heartbeat_event: EventSource | null = null;
+	abort_controller: AbortController | null = null;
+	stream_instance: EventSource | null = null;
+	current_payload: any;
+	ws_map: Record<string, WebSocket | "pending" | "failed" | "closed"> = {};
+
+	get_url_config(url: string | null = null): Config {
+		if (!this.config) {
+			throw new Error(CONFIG_ERROR_MSG);
+		}
+		if (url === null) {
+			url = window.location.href;
+		}
+		const stripSlashes = (str: string): string => str.replace(/^\/+|\/+$/g, "");
+		let root_path = stripSlashes(new URL(this.config.root).pathname);
+		let url_path = stripSlashes(new URL(url).pathname);
+		let page: string;
+		if (!url_path.startsWith(root_path)) {
+			page = "";
+		} else {
+			page = stripSlashes(url_path.substring(root_path.length));
+		}
+		return this.get_page_config(page);
+	}
+	get_page_config(page: string): Config {
+		if (!this.config) {
+			throw new Error(CONFIG_ERROR_MSG);
+		}
+		let config = this.config;
+		if (!(page in config.page)) {
+			page = "";
+		}
+		return {
+			...config,
+			current_page: page,
+			layout: config.page[page].layout,
+			components: config.components.filter((c) =>
+				config.page[page].components.includes(c.id)
+			),
+			dependencies: this.config.dependencies.filter((d) =>
+				config.page[page].dependencies.includes(d.id)
+			)
+		};
+	}
+
+	fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
+		const headers = new Headers(init?.headers || {});
+		if (this && this.cookies) {
+			headers.append("Cookie", this.cookies);
+		}
+		if (this && this.options.headers) {
+			for (const name in this.options.headers) {
+				headers.append(name, this.options.headers[name]);
+			}
+		}
+
+		return fetch(input, { ...init, headers });
+	}
+
+	stream(url: URL): EventSource {
+		const headers = new Headers();
+		if (this && this.cookies) {
+			headers.append("Cookie", this.cookies);
+		}
+		if (this && this.options.headers) {
+			for (const name in this.options.headers) {
+				headers.append(name, this.options.headers[name]);
+			}
+		}
+		if (this && this.options.hf_token) {
+			headers.append("Authorization", `Bearer ${this.options.hf_token}`);
+		}
+
+		this.abort_controller = new AbortController();
+
+		this.stream_instance = readable_stream(url.toString(), {
+			credentials: "include",
+			headers: headers,
+			signal: this.abort_controller.signal
+		});
+
+		return this.stream_instance;
+	}
+
+	view_api: () => Promise<ApiInfo<JsApiData>>;
+	upload_files: (
+		root_url: string,
+		files: (Blob | File)[],
+		upload_id?: string
+	) => Promise<UploadResponse>;
+	upload: (
+		file_data: FileData[],
+		root_url: string,
+		upload_id?: string,
+		max_file_size?: number
+	) => Promise<(FileData | null)[] | null>;
+	handle_blob: (
+		endpoint: string,
+		data: unknown[],
+		endpoint_info: EndpointInfo<ApiData | JsApiData>
+	) => Promise<unknown[]>;
+	post_data: (
+		url: string,
+		body: unknown,
+		additional_headers?: any
+	) => Promise<unknown[]>;
+	submit: (
+		endpoint: string | number,
+		data: unknown[] | Record<string, unknown> | undefined,
+		event_data?: unknown,
+		trigger_id?: number | null,
+		all_events?: boolean
+	) => SubmitIterable<GradioEvent>;
+	predict: (
+		endpoint: string | number,
+		data: unknown[] | Record<string, unknown> | undefined,
+		event_data?: unknown
+	) => Promise<PredictReturn>;
+	open_stream: () => Promise<void>;
+	private resolve_config: (endpoint: string) => Promise<Config | undefined>;
+	private resolve_cookies: () => Promise<void>;
+	constructor(
+		app_reference: string,
+		options: ClientOptions = { events: ["data"] }
+	) {
+		this.app_reference = app_reference;
+		this.deep_link = options.query_params?.deep_link || null;
+		if (!options.events) {
+			options.events = ["data"];
+		}
+
+		this.options = options;
+		this.current_payload = {};
+		this.view_api = view_api.bind(this);
+		this.upload_files = upload_files.bind(this);
+		this.handle_blob = handle_blob.bind(this);
+		this.post_data = post_data.bind(this);
+		this.submit = submit.bind(this);
+		this.predict = predict.bind(this);
+		this.open_stream = open_stream.bind(this);
+		this.resolve_config = resolve_config.bind(this);
+		this.resolve_cookies = resolve_cookies.bind(this);
+		this.upload = upload.bind(this);
+		this.fetch = this.fetch.bind(this);
+		this.handle_space_success = this.handle_space_success.bind(this);
+		this.stream = this.stream.bind(this);
+	}
+
+	private async init(): Promise<void> {
+		if (
+			(typeof window === "undefined" || !("WebSocket" in window)) &&
+			!global.WebSocket
+		) {
+			if (!BROWSER_BUILD) {
+				const ws = await import("ws");
+				global.WebSocket = ws.WebSocket as unknown as typeof WebSocket;
+			}
+		}
+
+		if (this.options.auth) {
+			await this.resolve_cookies();
+		}
+
+		await this._resolve_config().then(({ config }) =>
+			this._resolve_heartbeat(config)
+		);
+
+		this.api_info = await this.view_api();
+		this.api_map = map_names_to_ids(this.config?.dependencies || []);
+	}
+
+	async _resolve_heartbeat(_config: Config): Promise<void> {
+		if (_config) {
+			this.config = _config;
+			this.api_prefix = _config.api_prefix || "";
+
+			if (this.config && this.config.connect_heartbeat) {
+				if (this.config.space_id && this.options.hf_token) {
+					this.jwt = await get_jwt(
+						this.config.space_id,
+						this.options.hf_token,
+						this.cookies
+					);
+				}
+			}
+		}
+
+		if (_config.space_id && this.options.hf_token) {
+			this.jwt = await get_jwt(_config.space_id, this.options.hf_token);
+		}
+
+		if (this.config && this.config.connect_heartbeat) {
+			// connect to the heartbeat endpoint via GET request
+			const heartbeat_url = new URL(
+				`${this.config.root}${this.api_prefix}/${HEARTBEAT_URL}/${this.session_hash}`
+			);
+
+			// if the jwt is available, add it to the query params
+			if (this.jwt) {
+				heartbeat_url.searchParams.set("__sign", this.jwt);
+			}
+
+			// Just connect to the endpoint without parsing the response. Ref: https://github.com/gradio-app/gradio/pull/7974#discussion_r1557717540
+			if (!this.heartbeat_event) {
+				this.heartbeat_event = this.stream(heartbeat_url);
+			}
+		}
+	}
+
+	static async connect(
+		app_reference: string,
+		options: ClientOptions = {
+			events: ["data"]
+		}
+	): Promise<Client> {
+		const client = new this(app_reference, options); // this refers to the class itself, not the instance
+		if (options.session_hash) {
+			client.session_hash = options.session_hash;
+		}
+		await client.init();
+		return client;
+	}
+
+	async reconnect(): Promise<"connected" | "broken" | "changed"> {
+		const app_id_url = new URL(
+			`${this.config!.root}${this.api_prefix}/${APP_ID_URL}`
+		);
+		let app_id: string;
+		try {
+			const response = await this.fetch(app_id_url);
+			if (!response.ok) {
+				throw new Error();
+			}
+			app_id = ((await response.json()) as any).app_id;
+		} catch (e) {
+			return "broken";
+		}
+		if (app_id !== this.config!.app_id) {
+			return "changed";
+		}
+		return "connected";
+	}
+
+	close(): void {
+		this.closed = true;
+		close_stream(this.stream_status, this.abort_controller);
+	}
+
+	set_current_payload(payload: any): void {
+		this.current_payload = payload;
+	}
+
+	static async duplicate(
+		app_reference: string,
+		options: DuplicateOptions = {
+			events: ["data"]
+		}
+	): Promise<Client> {
+		return duplicate(app_reference, options);
+	}
+
+	private async _resolve_config(): Promise<any> {
+		const { http_protocol, host, space_id } = await process_endpoint(
+			this.app_reference,
+			this.options.hf_token
+		);
+
+		const { status_callback } = this.options;
+
+		if (space_id && status_callback) {
+			await check_and_wake_space(space_id, status_callback);
+		}
+
+		let config: Config | undefined;
+
+		try {
+			// Create base URL
+			let configUrl = `${http_protocol}//${host}`;
+			config = await this.resolve_config(configUrl);
+
+			if (!config) {
+				throw new Error(CONFIG_ERROR_MSG);
+			}
+
+			return this.config_success(config);
+		} catch (e: any) {
+			if (space_id && status_callback) {
+				check_space_status(
+					space_id,
+					RE_SPACE_NAME.test(space_id) ? "space_name" : "subdomain",
+					this.handle_space_success
+				);
+			} else {
+				if (status_callback)
+					status_callback({
+						status: "error",
+						message: "Could not load this space.",
+						load_status: "error",
+						detail: "NOT_FOUND"
+					});
+				throw Error(e);
+			}
+		}
+	}
+
+	private async config_success(
+		_config: Config
+	): Promise<Config | client_return> {
+		this.config = _config;
+		this.api_prefix = _config.api_prefix || "";
+
+		if (this.config.auth_required) {
+			return this.prepare_return_obj();
+		}
+
+		try {
+			this.api_info = await this.view_api();
+		} catch (e) {
+			console.error(API_INFO_ERROR_MSG + (e as Error).message);
+		}
+
+		return this.prepare_return_obj();
+	}
+
+	async handle_space_success(status: SpaceStatus): Promise<Config | void> {
+		if (!this) {
+			throw new Error(CONFIG_ERROR_MSG);
+		}
+		const { status_callback } = this.options;
+		if (status_callback) status_callback(status);
+		if (status.status === "running") {
+			try {
+				this.config = await this._resolve_config();
+				this.api_prefix = this?.config?.api_prefix || "";
+
+				if (!this.config) {
+					throw new Error(CONFIG_ERROR_MSG);
+				}
+
+				const _config = await this.config_success(this.config);
+
+				return _config as Config;
+			} catch (e) {
+				if (status_callback) {
+					status_callback({
+						status: "error",
+						message: "Could not load this space.",
+						load_status: "error",
+						detail: "NOT_FOUND"
+					});
+				}
+				throw e;
+			}
+		}
+	}
+
+	public async component_server(
+		component_id: number,
+		fn_name: string,
+		data: unknown[] | { binary: boolean; data: Record<string, any> }
+	): Promise<unknown> {
+		if (!this.config) {
+			throw new Error(CONFIG_ERROR_MSG);
+		}
+
+		const headers: {
+			Authorization?: string;
+			"Content-Type"?: "application/json";
+		} = {};
+
+		const { hf_token } = this.options;
+		const { session_hash } = this;
+
+		if (hf_token) {
+			headers.Authorization = `Bearer ${this.options.hf_token}`;
+		}
+
+		let root_url: string;
+		let component = this.config.components.find(
+			(comp) => comp.id === component_id
+		);
+		if (component?.props?.root_url) {
+			root_url = component.props.root_url;
+		} else {
+			root_url = this.config.root;
+		}
+
+		let body: FormData | string;
+
+		if ("binary" in data) {
+			body = new FormData();
+			for (const key in data.data) {
+				if (key === "binary") continue;
+				body.append(key, data.data[key]);
+			}
+			body.set("component_id", component_id.toString());
+			body.set("fn_name", fn_name);
+			body.set("session_hash", session_hash);
+		} else {
+			body = JSON.stringify({
+				data: data,
+				component_id,
+				fn_name,
+				session_hash
+			});
+
+			headers["Content-Type"] = "application/json";
+		}
+
+		if (hf_token) {
+			headers.Authorization = `Bearer ${hf_token}`;
+		}
+
+		try {
+			const response = await this.fetch(
+				`${root_url}${this.api_prefix}/${COMPONENT_SERVER_URL}/`,
+				{
+					method: "POST",
+					body: body,
+					headers,
+					credentials: "include"
+				}
+			);
+
+			if (!response.ok) {
+				throw new Error(
+					"Could not connect to component server: " + response.statusText
+				);
+			}
+
+			const output = await response.json();
+			return output;
+		} catch (e) {
+			console.warn(e);
+		}
+	}
+
+	public set_cookies(raw_cookies: string): void {
+		this.cookies = parse_and_set_cookies(raw_cookies).join("; ");
+	}
+
+	private prepare_return_obj(): client_return {
+		return {
+			config: this.config,
+			predict: this.predict,
+			submit: this.submit,
+			view_api: this.view_api,
+			component_server: this.component_server
+		};
+	}
+
+	private async connect_ws(url: string): Promise<void> {
+		return new Promise((resolve, reject) => {
+			let ws;
+			try {
+				ws = new WebSocket(url);
+			} catch (e) {
+				this.ws_map[url] = "failed";
+				return;
+			}
+
+			this.ws_map[url] = "pending";
+			ws.onopen = () => {
+				this.ws_map[url] = ws;
+				resolve();
+			};
+
+			ws.onerror = (error) => {
+				console.error("WebSocket error:", error);
+				this.close_ws(url);
+				this.ws_map[url] = "failed";
+				resolve();
+			};
+
+			ws.onclose = () => {
+				this.ws_map[url] = "closed";
+			};
+
+			ws.onmessage = (event) => {};
+		});
+	}
+
+	async send_ws_message(url: string, data: any): Promise<void> {
+		// connect if not connected
+		if (!(url in this.ws_map)) {
+			await this.connect_ws(url);
+		} else if (
+			this.ws_map[url] === "pending" ||
+			this.ws_map[url] === "closed" ||
+			this.ws_map[url] === "failed"
+		) {
+			return;
+		}
+		const ws = this.ws_map[url];
+		if (ws instanceof WebSocket) {
+			ws.send(JSON.stringify(data));
+		} else {
+			this.post_data(url, data);
+		}
+	}
+
+	async close_ws(url: string): Promise<void> {
+		if (url in this.ws_map) {
+			const ws = this.ws_map[url];
+			if (ws instanceof WebSocket) {
+				ws.close();
+				delete this.ws_map[url];
+			}
+		}
+	}
+}
+
+/**
+ * @deprecated This method will be removed in v1.0. Use `Client.connect()` instead.
+ * Creates a client instance for interacting with Gradio apps.
+ *
+ * @param {string} app_reference - The reference or URL to a Gradio space or app.
+ * @param {ClientOptions} options - Configuration options for the client.
+ * @returns {Promise<Client>} A promise that resolves to a `Client` instance.
+ */
+export async function client(
+	app_reference: string,
+	options: ClientOptions = {
+		events: ["data"]
+	}
+): Promise<Client> {
+	return await Client.connect(app_reference, options);
+}
+
+/**
+ * @deprecated This method will be removed in v1.0. Use `Client.duplicate()` instead.
+ * Creates a duplicate of a space and returns a client instance for the duplicated space.
+ *
+ * @param {string} app_reference - The reference or URL to a Gradio space or app to duplicate.
+ * @param {DuplicateOptions} options - Configuration options for the client.
+ * @returns {Promise<Client>} A promise that resolves to a `Client` instance.
+ */
+export async function duplicate_space(
+	app_reference: string,
+	options: DuplicateOptions
+): Promise<Client> {
+	return await Client.duplicate(app_reference, options);
+}
+
+export type ClientInstance = Client;

5.49.1/client/src/constants.ts

@@ -0,0 +1,41 @@
+// endpoints
+export const HOST_URL = `host`;
+export const API_URL = `predict/`;
+export const SSE_URL_V0 = `queue/join`;
+export const SSE_DATA_URL_V0 = `queue/data`;
+export const SSE_URL = `queue/data`;
+export const SSE_DATA_URL = `queue/join`;
+export const UPLOAD_URL = `upload`;
+export const LOGIN_URL = `login`;
+export const CONFIG_URL = `config`;
+export const API_INFO_URL = `info`;
+export const RUNTIME_URL = `runtime`;
+export const SLEEPTIME_URL = `sleeptime`;
+export const HEARTBEAT_URL = `heartbeat`;
+export const COMPONENT_SERVER_URL = `component_server`;
+export const RESET_URL = `reset`;
+export const CANCEL_URL = `cancel`;
+export const APP_ID_URL = `app_id`;
+
+export const RAW_API_INFO_URL = `info?serialize=False`;
+export const SPACE_FETCHER_URL =
+	"https://gradio-space-api-fetcher-v2.hf.space/api";
+export const SPACE_URL = "https://hf.space/{}";
+
+// messages
+export const QUEUE_FULL_MSG =
+	"This application is currently busy. Please try again. ";
+export const BROKEN_CONNECTION_MSG = "Connection errored out. ";
+export const CONFIG_ERROR_MSG = "Could not resolve app config. ";
+export const SPACE_STATUS_ERROR_MSG = "Could not get space status. ";
+export const API_INFO_ERROR_MSG = "Could not get API info. ";
+export const SPACE_METADATA_ERROR_MSG = "Space metadata could not be loaded. ";
+export const INVALID_URL_MSG = "Invalid URL. A full URL path is required.";
+export const UNAUTHORIZED_MSG = "Not authorized to access this space. ";
+export const INVALID_CREDENTIALS_MSG = "Invalid credentials. Could not login. ";
+export const MISSING_CREDENTIALS_MSG =
+	"Login credentials are required to access this space.";
+export const NODEJS_FS_ERROR_MSG =
+	"File system access is only available in Node.js environments";
+export const ROOT_URL_ERROR_MSG = "Root URL not found in client config";
+export const FILE_PROCESSING_ERROR_MSG = "Error uploading file";

5.49.1/client/src/globals.d.ts

@@ -0,0 +1,12 @@
+import { ApiData, ApiInfo, Config } from "./types";
+
+declare global {
+	interface Window {
+		__gradio_mode__: "app" | "website";
+		gradio_config: Config;
+		gradio_api_info: ApiInfo<ApiData> | { api: ApiInfo<ApiData> };
+		__is_colab__: boolean;
+		__gradio_space__: string | null;
+		supports_zerogpu_headers?: boolean;
+	}
+}

5.49.1/client/src/helpers/api_info.ts

@@ -0,0 +1,476 @@
+import {
+	HOST_URL,
+	INVALID_URL_MSG,
+	QUEUE_FULL_MSG,
+	SPACE_METADATA_ERROR_MSG
+} from "../constants";
+import type {
+	ApiData,
+	ApiInfo,
+	Config,
+	JsApiData,
+	EndpointInfo,
+	Status
+} from "../types";
+import { determine_protocol } from "./init_helpers";
+
+export const RE_SPACE_NAME = /^[a-zA-Z0-9_\-\.]+\/[a-zA-Z0-9_\-\.]+$/;
+export const RE_SPACE_DOMAIN = /.*hf\.space\/{0,1}.*$/;
+
+export async function process_endpoint(
+	app_reference: string,
+	hf_token?: `hf_${string}`
+): Promise<{
+	space_id: string | false;
+	host: string;
+	ws_protocol: "ws" | "wss";
+	http_protocol: "http:" | "https:";
+}> {
+	const headers: { Authorization?: string } = {};
+	if (hf_token) {
+		headers.Authorization = `Bearer ${hf_token}`;
+	}
+
+	const _app_reference = app_reference.trim().replace(/\/$/, "");
+
+	if (RE_SPACE_NAME.test(_app_reference)) {
+		// app_reference is a HF space name
+		try {
+			const res = await fetch(
+				`https://huggingface.co/api/spaces/${_app_reference}/${HOST_URL}`,
+				{ headers }
+			);
+
+			const _host = (await res.json()).host;
+
+			return {
+				space_id: app_reference,
+				...determine_protocol(_host)
+			};
+		} catch (e) {
+			throw new Error(SPACE_METADATA_ERROR_MSG);
+		}
+	}
+
+	if (RE_SPACE_DOMAIN.test(_app_reference)) {
+		// app_reference is a direct HF space domain
+		const { ws_protocol, http_protocol, host } =
+			determine_protocol(_app_reference);
+
+		return {
+			space_id: host.split("/")[0].replace(".hf.space", ""),
+			ws_protocol,
+			http_protocol,
+			host
+		};
+	}
+
+	return {
+		space_id: false,
+		...determine_protocol(_app_reference)
+	};
+}
+
+export const join_urls = (...urls: string[]): string => {
+	try {
+		return urls.reduce((base_url: string, part: string) => {
+			base_url = base_url.replace(/\/+$/, "");
+			part = part.replace(/^\/+/, "");
+			return new URL(part, base_url + "/").toString();
+		});
+	} catch (e) {
+		throw new Error(INVALID_URL_MSG);
+	}
+};
+
+export function transform_api_info(
+	api_info: ApiInfo<ApiData>,
+	config: Config,
+	api_map: Record<string, number>
+): ApiInfo<JsApiData> {
+	const transformed_info: ApiInfo<JsApiData> = {
+		named_endpoints: {},
+		unnamed_endpoints: {}
+	};
+
+	Object.keys(api_info).forEach((category) => {
+		if (category === "named_endpoints" || category === "unnamed_endpoints") {
+			transformed_info[category] = {};
+
+			Object.entries(api_info[category]).forEach(
+				([endpoint, { parameters, returns }]) => {
+					const dependencyIndex =
+						config.dependencies.find(
+							(dep) =>
+								dep.api_name === endpoint ||
+								dep.api_name === endpoint.replace("/", "")
+						)?.id ||
+						api_map[endpoint.replace("/", "")] ||
+						-1;
+
+					const dependencyTypes =
+						dependencyIndex !== -1
+							? config.dependencies.find((dep) => dep.id == dependencyIndex)
+									?.types
+							: { generator: false, cancel: false };
+
+					if (
+						dependencyIndex !== -1 &&
+						config.dependencies.find((dep) => dep.id == dependencyIndex)?.inputs
+							?.length !== parameters.length
+					) {
+						const components = config.dependencies
+							.find((dep) => dep.id == dependencyIndex)!
+							.inputs.map(
+								(input) => config.components.find((c) => c.id === input)?.type
+							);
+
+						try {
+							components.forEach((comp, idx) => {
+								if (comp === "state") {
+									const new_param = {
+										component: "state",
+										example: null,
+										parameter_default: null,
+										parameter_has_default: true,
+										parameter_name: null,
+										hidden: true
+									};
+
+									// @ts-ignore
+									parameters.splice(idx, 0, new_param);
+								}
+							});
+						} catch (e) {
+							console.error(e);
+						}
+					}
+
+					const transform_type = (
+						data: ApiData,
+						component: string,
+						serializer: string,
+						signature_type: "return" | "parameter"
+					): JsApiData => ({
+						...data,
+						description: get_description(data?.type, serializer),
+						type:
+							get_type(data?.type, component, serializer, signature_type) || ""
+					});
+
+					transformed_info[category][endpoint] = {
+						parameters: parameters.map((p: ApiData) =>
+							transform_type(p, p?.component, p?.serializer, "parameter")
+						),
+						returns: returns.map((r: ApiData) =>
+							transform_type(r, r?.component, r?.serializer, "return")
+						),
+						type: dependencyTypes
+					};
+				}
+			);
+		}
+	});
+
+	return transformed_info;
+}
+
+export function get_type(
+	type: { type: any; description: string },
+	component: string,
+	serializer: string,
+	signature_type: "return" | "parameter"
+): string | undefined {
+	if (component === "Api") return type.type;
+	switch (type?.type) {
+		case "string":
+			return "string";
+		case "boolean":
+			return "boolean";
+		case "number":
+			return "number";
+	}
+
+	if (
+		serializer === "JSONSerializable" ||
+		serializer === "StringSerializable"
+	) {
+		return "any";
+	} else if (serializer === "ListStringSerializable") {
+		return "string[]";
+	} else if (component === "Image") {
+		return signature_type === "parameter" ? "Blob | File | Buffer" : "string";
+	} else if (serializer === "FileSerializable") {
+		if (type?.type === "array") {
+			return signature_type === "parameter"
+				? "(Blob | File | Buffer)[]"
+				: `{ name: string; data: string; size?: number; is_file?: boolean; orig_name?: string}[]`;
+		}
+		return signature_type === "parameter"
+			? "Blob | File | Buffer"
+			: `{ name: string; data: string; size?: number; is_file?: boolean; orig_name?: string}`;
+	} else if (serializer === "GallerySerializable") {
+		return signature_type === "parameter"
+			? "[(Blob | File | Buffer), (string | null)][]"
+			: `[{ name: string; data: string; size?: number; is_file?: boolean; orig_name?: string}, (string | null))][]`;
+	}
+}
+
+export function get_description(
+	type: { type: any; description: string },
+	serializer: string
+): string {
+	if (serializer === "GallerySerializable") {
+		return "array of [file, label] tuples";
+	} else if (serializer === "ListStringSerializable") {
+		return "array of strings";
+	} else if (serializer === "FileSerializable") {
+		return "array of files or single file";
+	}
+	return type?.description;
+}
+
+/* eslint-disable complexity */
+export function handle_message(
+	data: any,
+	last_status: Status["stage"]
+): {
+	type:
+		| "hash"
+		| "data"
+		| "update"
+		| "complete"
+		| "generating"
+		| "log"
+		| "none"
+		| "heartbeat"
+		| "streaming"
+		| "broken_connection"
+		| "unexpected_error";
+	data?: any;
+	status?: Status;
+	original_msg?: string;
+} {
+	const queue = true;
+	switch (data.msg) {
+		case "send_data":
+			return { type: "data" };
+		case "send_hash":
+			return { type: "hash" };
+		case "queue_full":
+			return {
+				type: "update",
+				status: {
+					queue,
+					message: QUEUE_FULL_MSG,
+					stage: "error",
+					code: data.code,
+					success: data.success
+				}
+			};
+		case "heartbeat":
+			return {
+				type: "heartbeat"
+			};
+		case "unexpected_error":
+			return {
+				type: "unexpected_error",
+				status: {
+					queue,
+					message: data.message,
+					session_not_found: data.session_not_found,
+					stage: "error",
+					success: false
+				}
+			};
+		case "broken_connection":
+			return {
+				type: "broken_connection",
+				status: {
+					queue,
+					message: data.message,
+					stage: "error",
+					success: false
+				}
+			};
+		case "estimation":
+			return {
+				type: "update",
+				status: {
+					queue,
+					stage: last_status || "pending",
+					code: data.code,
+					size: data.queue_size,
+					position: data.rank,
+					eta: data.rank_eta,
+					success: data.success
+				}
+			};
+		case "progress":
+			return {
+				type: "update",
+				status: {
+					queue,
+					stage: "pending",
+					code: data.code,
+					progress_data: data.progress_data,
+					success: data.success
+				}
+			};
+		case "log":
+			return { type: "log", data: data };
+		case "process_generating":
+			return {
+				type: "generating",
+				status: {
+					queue,
+					message: !data.success ? data.output.error : null,
+					stage: data.success ? "generating" : "error",
+					code: data.code,
+					progress_data: data.progress_data,
+					eta: data.average_duration,
+					changed_state_ids: data.success
+						? data.output.changed_state_ids
+						: undefined
+				},
+				data: data.success ? data.output : null
+			};
+		case "process_streaming":
+			return {
+				type: "streaming",
+				status: {
+					queue,
+					message: data.output.error,
+					stage: "streaming",
+					time_limit: data.time_limit,
+					code: data.code,
+					progress_data: data.progress_data,
+					eta: data.eta
+				},
+				data: data.output
+			};
+		case "process_completed":
+			if ("error" in data.output) {
+				return {
+					type: "update",
+					status: {
+						queue,
+						title: data.output.title as string,
+						message: data.output.error as string,
+						visible: data.output.visible as boolean,
+						duration: data.output.duration as number,
+						stage: "error",
+						code: data.code,
+						success: data.success
+					}
+				};
+			}
+			return {
+				type: "complete",
+				status: {
+					queue,
+					message: !data.success ? data.output.error : undefined,
+					stage: data.success ? "complete" : "error",
+					code: data.code,
+					progress_data: data.progress_data,
+					changed_state_ids: data.success
+						? data.output.changed_state_ids
+						: undefined
+				},
+				data: data.success ? data.output : null
+			};
+
+		case "process_starts":
+			return {
+				type: "update",
+				status: {
+					queue,
+					stage: "pending",
+					code: data.code,
+					size: data.rank,
+					position: 0,
+					success: data.success,
+					eta: data.eta
+				},
+				original_msg: "process_starts"
+			};
+	}
+
+	return { type: "none", status: { stage: "error", queue } };
+}
+/* eslint-enable complexity */
+
+/**
+ * Maps the provided `data` to the parameters defined by the `/info` endpoint response.
+ * This allows us to support both positional and keyword arguments passed to the client
+ * and ensures that all parameters are either directly provided or have default values assigned.
+ *
+ * @param {unknown[] | Record<string, unknown>} data - The input data for the function,
+ *        which can be either an array of values for positional arguments or an object
+ *        with key-value pairs for keyword arguments.
+ * @param {JsApiData[]} parameters - Array of parameter descriptions retrieved from the
+ *        `/info` endpoint.
+ *
+ * @returns {unknown[]} - Returns an array of resolved data where each element corresponds
+ *         to the expected parameter from the API. The `parameter_default` value is used where
+ *         a value is not provided for a parameter, and optional parameters without defaults are
+ * 		   set to `undefined`.
+ *
+ * @throws {Error} - Throws an error:
+ *         - If more arguments are provided than are defined in the parameters.
+ *  *      - If no parameter value is provided for a required parameter and no default value is defined.
+ *         - If an argument is provided that does not match any defined parameter.
+ */
+
+export const map_data_to_params = (
+	data: unknown[] | Record<string, unknown> = [],
+	endpoint_info: EndpointInfo<JsApiData | ApiData>
+): unknown[] => {
+	// Workaround for the case where the endpoint_info is undefined
+	// See https://github.com/gradio-app/gradio/pull/8820#issuecomment-2237381761
+	const parameters = endpoint_info ? endpoint_info.parameters : [];
+
+	if (Array.isArray(data)) {
+		if (
+			endpoint_info &&
+			parameters.length > 0 &&
+			data.length > parameters.length
+		) {
+			console.warn("Too many arguments provided for the endpoint.");
+		}
+		return data;
+	}
+
+	const resolved_data: unknown[] = [];
+	const provided_keys = Object.keys(data);
+
+	parameters.forEach((param, index) => {
+		if (data.hasOwnProperty(param.parameter_name)) {
+			resolved_data[index] = data[param.parameter_name];
+		} else if (param.parameter_has_default) {
+			resolved_data[index] = param.parameter_default;
+		} else {
+			throw new Error(
+				`No value provided for required parameter: ${param.parameter_name}`
+			);
+		}
+	});
+
+	provided_keys.forEach((key) => {
+		if (!parameters.some((param) => param.parameter_name === key)) {
+			throw new Error(
+				`Parameter \`${key}\` is not a valid keyword argument. Please refer to the API for usage.`
+			);
+		}
+	});
+
+	resolved_data.forEach((value, idx) => {
+		if (value === undefined && !parameters[idx].parameter_has_default) {
+			throw new Error(
+				`No value provided for required parameter: ${parameters[idx].parameter_name}`
+			);
+		}
+	});
+
+	return resolved_data;
+};

5.49.1/client/src/helpers/data.ts

@@ -0,0 +1,221 @@
+import {
+	type ApiData,
+	type BlobRef,
+	type Config,
+	type EndpointInfo,
+	type JsApiData,
+	type DataType,
+	Command,
+	type Dependency,
+	type ComponentMeta
+} from "../types";
+import { FileData } from "../upload";
+
+const is_node =
+	typeof process !== "undefined" && process.versions && process.versions.node;
+
+export function update_object(
+	object: { [x: string]: any },
+	newValue: any,
+	stack: (string | number)[]
+): void {
+	while (stack.length > 1) {
+		const key = stack.shift();
+		if (typeof key === "string" || typeof key === "number") {
+			object = object[key];
+		} else {
+			throw new Error("Invalid key type");
+		}
+	}
+
+	const key = stack.shift();
+	if (typeof key === "string" || typeof key === "number") {
+		object[key] = newValue;
+	} else {
+		throw new Error("Invalid key type");
+	}
+}
+
+export async function walk_and_store_blobs(
+	data: DataType,
+	type: string | undefined = undefined,
+	path: string[] = [],
+	root = false,
+	endpoint_info: EndpointInfo<ApiData | JsApiData> | undefined = undefined
+): Promise<BlobRef[]> {
+	if (Array.isArray(data)) {
+		let blob_refs: BlobRef[] = [];
+
+		await Promise.all(
+			data.map(async (_, index) => {
+				let new_path = path.slice();
+				new_path.push(String(index));
+
+				const array_refs = await walk_and_store_blobs(
+					data[index],
+					root
+						? endpoint_info?.parameters[index]?.component || undefined
+						: type,
+					new_path,
+					false,
+					endpoint_info
+				);
+
+				blob_refs = blob_refs.concat(array_refs);
+			})
+		);
+
+		return blob_refs;
+	} else if (
+		(globalThis.Buffer && data instanceof globalThis.Buffer) ||
+		data instanceof Blob
+	) {
+		return [
+			{
+				path: path,
+				blob: new Blob([data]),
+				type
+			}
+		];
+	} else if (typeof data === "object" && data !== null) {
+		let blob_refs: BlobRef[] = [];
+		for (const key of Object.keys(data) as (keyof typeof data)[]) {
+			const new_path = [...path, key];
+			const value = data[key];
+
+			blob_refs = blob_refs.concat(
+				await walk_and_store_blobs(
+					value,
+					undefined,
+					new_path,
+					false,
+					endpoint_info
+				)
+			);
+		}
+
+		return blob_refs;
+	}
+
+	return [];
+}
+
+export function skip_queue(id: number, config: Config): boolean {
+	let fn_queue = config?.dependencies?.find((dep) => dep.id == id)?.queue;
+	if (fn_queue != null) {
+		return !fn_queue;
+	}
+	return !config.enable_queue;
+}
+
+// todo: add jsdoc for this function
+
+export function post_message<Res = any>(
+	message: any,
+	origin: string
+): Promise<Res> {
+	return new Promise((res, _rej) => {
+		const channel = new MessageChannel();
+		channel.port1.onmessage = (({ data }) => {
+			channel.port1.close();
+			res(data);
+		}) as (ev: MessageEvent<Res>) => void;
+		window.parent.postMessage(message, origin, [channel.port2]);
+	});
+}
+
+export function handle_file(
+	file_or_url: File | string | Blob | Buffer
+): FileData | Blob | Command {
+	if (typeof file_or_url === "string") {
+		if (
+			file_or_url.startsWith("http://") ||
+			file_or_url.startsWith("https://")
+		) {
+			return {
+				path: file_or_url,
+				url: file_or_url,
+				orig_name: file_or_url.split("/").pop() ?? "unknown",
+				meta: { _type: "gradio.FileData" }
+			};
+		}
+
+		if (is_node) {
+			// Handle local file paths
+			return new Command("upload_file", {
+				path: file_or_url,
+				name: file_or_url,
+				orig_path: file_or_url
+			});
+		}
+	} else if (typeof File !== "undefined" && file_or_url instanceof File) {
+		return new Blob([file_or_url]);
+	} else if (file_or_url instanceof Buffer) {
+		return new Blob([file_or_url]);
+	} else if (file_or_url instanceof Blob) {
+		return file_or_url;
+	}
+	throw new Error(
+		"Invalid input: must be a URL, File, Blob, or Buffer object."
+	);
+}
+
+/**
+ * Handles the payload by filtering out state inputs and returning an array of resolved payload values.
+ * We send null values for state inputs to the server, but we don't want to include them in the resolved payload.
+ *
+ * @param resolved_payload - The resolved payload values received from the client or the server
+ * @param dependency - The dependency object.
+ * @param components - The array of component metadata.
+ * @param with_null_state - Optional. Specifies whether to include null values for state inputs. Default is false.
+ * @returns An array of resolved payload values, filtered based on the dependency and component metadata.
+ */
+export function handle_payload(
+	resolved_payload: unknown[],
+	dependency: Dependency,
+	components: ComponentMeta[],
+	type: "input" | "output",
+	with_null_state = false
+): unknown[] {
+	if (type === "input" && !with_null_state) {
+		throw new Error("Invalid code path. Cannot skip state inputs for input.");
+	}
+	// data comes from the server with null state values so we skip
+	if (type === "output" && with_null_state) {
+		return resolved_payload;
+	}
+
+	let updated_payload: unknown[] = [];
+	let payload_index = 0;
+	const deps = type === "input" ? dependency.inputs : dependency.outputs;
+	for (let i = 0; i < deps.length; i++) {
+		const input_id = deps[i];
+		const component = components.find((c) => c.id === input_id);
+
+		if (component?.type === "state") {
+			// input + with_null_state needs us to fill state with null values
+			if (with_null_state) {
+				if (resolved_payload.length === deps.length) {
+					const value = resolved_payload[payload_index];
+					updated_payload.push(value);
+					payload_index++;
+				} else {
+					updated_payload.push(null);
+				}
+			} else {
+				// this is output & !with_null_state, we skip state inputs
+				// the server payload always comes with null state values so we move along the payload index
+				payload_index++;
+				continue;
+			}
+			// input & !with_null_state isn't a case we care about, server needs null
+			continue;
+		} else {
+			const value = resolved_payload[payload_index];
+			updated_payload.push(value);
+			payload_index++;
+		}
+	}
+
+	return updated_payload;
+}

5.49.1/client/src/helpers/init_helpers.ts

@@ -0,0 +1,247 @@
+import type { Config } from "../types";
+import {
+	CONFIG_ERROR_MSG,
+	CONFIG_URL,
+	INVALID_CREDENTIALS_MSG,
+	LOGIN_URL,
+	MISSING_CREDENTIALS_MSG,
+	SPACE_METADATA_ERROR_MSG,
+	UNAUTHORIZED_MSG
+} from "../constants";
+import { Client } from "..";
+import { join_urls, process_endpoint } from "./api_info";
+
+/**
+ * This function is used to resolve the URL for making requests when the app has a root path.
+ * The root path could be a path suffix like "/app" which is appended to the end of the base URL. Or
+ * it could be a full URL like "https://abidlabs-test-client-replica--gqf2x.hf.space" which is used when hosting
+ * Gradio apps on Hugging Face Spaces.
+ * @param {string} base_url The base URL at which the Gradio server is hosted
+ * @param {string} root_path The root path, which could be a path suffix (e.g. mounted in FastAPI app) or a full URL (e.g. hosted on Hugging Face Spaces)
+ * @param {boolean} prioritize_base Whether to prioritize the base URL over the root path. This is used when both the base path and root paths are full URLs. For example, for fetching files the root path should be prioritized, but for making requests, the base URL should be prioritized.
+ * @returns {string} the resolved URL
+ */
+export function resolve_root(
+	base_url: string,
+	root_path: string,
+	prioritize_base: boolean
+): string {
+	if (root_path.startsWith("http://") || root_path.startsWith("https://")) {
+		return prioritize_base ? base_url : root_path;
+	}
+	return base_url + root_path;
+}
+
+export async function get_jwt(
+	space: string,
+	token: `hf_${string}`,
+	cookies?: string | null
+): Promise<string | false> {
+	try {
+		const r = await fetch(`https://huggingface.co/api/spaces/${space}/jwt`, {
+			headers: {
+				Authorization: `Bearer ${token}`,
+				...(cookies ? { Cookie: cookies } : {})
+			}
+		});
+
+		const jwt = (await r.json()).token;
+
+		return jwt || false;
+	} catch (e) {
+		return false;
+	}
+}
+
+export function map_names_to_ids(
+	fns: Config["dependencies"]
+): Record<string, number> {
+	let apis: Record<string, number> = {};
+
+	fns.forEach(({ api_name, id }) => {
+		if (api_name) apis[api_name] = id;
+	});
+	return apis;
+}
+
+export async function resolve_config(
+	this: Client,
+	endpoint: string
+): Promise<Config | undefined> {
+	const headers: Record<string, string> = this.options.hf_token
+		? { Authorization: `Bearer ${this.options.hf_token}` }
+		: {};
+
+	headers["Content-Type"] = "application/json";
+
+	if (
+		typeof window !== "undefined" &&
+		window.gradio_config &&
+		location.origin !== "http://localhost:9876"
+	) {
+		if (window.gradio_config.current_page) {
+			endpoint = endpoint.substring(0, endpoint.lastIndexOf("/"));
+		}
+		if (window.gradio_config.dev_mode) {
+			let config_url = join_urls(
+				endpoint,
+				this.deep_link
+					? CONFIG_URL + "?deep_link=" + this.deep_link
+					: CONFIG_URL
+			);
+			const response = await this.fetch(config_url, {
+				headers,
+				credentials: "include"
+			});
+			const config = await handleConfigResponse(
+				response,
+				endpoint,
+				!!this.options.auth
+			);
+			// @ts-ignore
+			window.gradio_config = {
+				...config,
+				current_page: window.gradio_config.current_page
+			};
+		}
+		window.gradio_config.root = endpoint;
+		// @ts-ignore
+		return { ...window.gradio_config } as Config;
+	} else if (endpoint) {
+		let config_url = join_urls(
+			endpoint,
+			this.deep_link ? CONFIG_URL + "?deep_link=" + this.deep_link : CONFIG_URL
+		);
+
+		const response = await this.fetch(config_url, {
+			headers,
+			credentials: "include"
+		});
+
+		return handleConfigResponse(response, endpoint, !!this.options.auth);
+	}
+
+	throw new Error(CONFIG_ERROR_MSG);
+}
+
+async function handleConfigResponse(
+	response: Response,
+	endpoint: string,
+	authorized: boolean
+): Promise<Config> {
+	if (response?.status === 401 && !authorized) {
+		const error_data = await response.json();
+		const auth_message = error_data?.detail?.auth_message;
+		throw new Error(auth_message || MISSING_CREDENTIALS_MSG);
+	} else if (response?.status === 401 && authorized) {
+		throw new Error(INVALID_CREDENTIALS_MSG);
+	}
+
+	if (response?.status === 200) {
+		let config = await response.json();
+		config.root = endpoint;
+		config.dependencies?.forEach((dep: any, i: number) => {
+			if (dep.id === undefined) {
+				dep.id = i;
+			}
+		});
+		return config;
+	} else if (response?.status === 401) {
+		throw new Error(UNAUTHORIZED_MSG);
+	}
+
+	throw new Error(CONFIG_ERROR_MSG);
+}
+
+export async function resolve_cookies(this: Client): Promise<void> {
+	const { http_protocol, host } = await process_endpoint(
+		this.app_reference,
+		this.options.hf_token
+	);
+
+	try {
+		if (this.options.auth) {
+			const cookie_header = await get_cookie_header(
+				http_protocol,
+				host,
+				this.options.auth,
+				this.fetch,
+				this.options.hf_token
+			);
+
+			if (cookie_header) this.set_cookies(cookie_header);
+		}
+	} catch (e: unknown) {
+		throw Error((e as Error).message);
+	}
+}
+
+// separating this from client-bound resolve_cookies so that it can be used in duplicate
+export async function get_cookie_header(
+	http_protocol: string,
+	host: string,
+	auth: [string, string],
+	_fetch: typeof fetch,
+	hf_token?: `hf_${string}`
+): Promise<string | null> {
+	const formData = new FormData();
+	formData.append("username", auth?.[0]);
+	formData.append("password", auth?.[1]);
+
+	let headers: { Authorization?: string } = {};
+
+	if (hf_token) {
+		headers.Authorization = `Bearer ${hf_token}`;
+	}
+
+	const res = await _fetch(`${http_protocol}//${host}/${LOGIN_URL}`, {
+		headers,
+		method: "POST",
+		body: formData,
+		credentials: "include"
+	});
+
+	if (res.status === 200) {
+		return res.headers.get("set-cookie");
+	} else if (res.status === 401) {
+		throw new Error(INVALID_CREDENTIALS_MSG);
+	} else {
+		throw new Error(SPACE_METADATA_ERROR_MSG);
+	}
+}
+
+export function determine_protocol(endpoint: string): {
+	ws_protocol: "ws" | "wss";
+	http_protocol: "http:" | "https:";
+	host: string;
+} {
+	if (endpoint.startsWith("http")) {
+		const { protocol, host, pathname } = new URL(endpoint);
+
+		return {
+			ws_protocol: protocol === "https:" ? "wss" : "ws",
+			http_protocol: protocol as "http:" | "https:",
+			host: host + (pathname !== "/" ? pathname : "")
+		};
+	}
+
+	// default to secure if no protocol is provided
+
+	return {
+		ws_protocol: "wss",
+		http_protocol: "https:",
+		host: new URL(endpoint).host
+	};
+}
+
+export const parse_and_set_cookies = (cookie_header: string): string[] => {
+	let cookies: string[] = [];
+	const parts = cookie_header.split(/,(?=\s*[^\s=;]+=[^\s=;]+)/);
+	parts.forEach((cookie) => {
+		const [cookie_name, cookie_value] = cookie.split(";")[0].split("=");
+		if (cookie_name && cookie_value) {
+			cookies.push(`${cookie_name.trim()}=${cookie_value.trim()}`);
+		}
+	});
+	return cookies;
+};

5.49.1/client/src/helpers/spaces.ts

@@ -0,0 +1,252 @@
+import {
+	RUNTIME_URL,
+	SLEEPTIME_URL,
+	SPACE_STATUS_ERROR_MSG
+} from "../constants";
+import { RE_SPACE_NAME } from "./api_info";
+import type { SpaceStatusCallback } from "../types";
+
+export async function check_space_status(
+	id: string,
+	type: "subdomain" | "space_name",
+	status_callback: SpaceStatusCallback
+): Promise<void> {
+	let endpoint =
+		type === "subdomain"
+			? `https://huggingface.co/api/spaces/by-subdomain/${id}`
+			: `https://huggingface.co/api/spaces/${id}`;
+	let response;
+	let _status;
+	try {
+		response = await fetch(endpoint);
+		_status = response.status;
+		if (_status !== 200) {
+			throw new Error();
+		}
+		response = await response.json();
+	} catch (e) {
+		status_callback({
+			status: "error",
+			load_status: "error",
+			message: SPACE_STATUS_ERROR_MSG,
+			detail: "NOT_FOUND"
+		});
+		return;
+	}
+
+	if (!response || _status !== 200) return;
+	const {
+		runtime: { stage },
+		id: space_name
+	} = response;
+
+	switch (stage) {
+		case "STOPPED":
+		case "SLEEPING":
+			status_callback({
+				status: "sleeping",
+				load_status: "pending",
+				message: "Space is asleep. Waking it up...",
+				detail: stage
+			});
+
+			setTimeout(() => {
+				check_space_status(id, type, status_callback);
+			}, 1000); // poll for status
+			break;
+		case "PAUSED":
+			status_callback({
+				status: "paused",
+				load_status: "error",
+				message:
+					"This space has been paused by the author. If you would like to try this demo, consider duplicating the space.",
+				detail: stage,
+				discussions_enabled: await discussions_enabled(space_name)
+			});
+			break;
+		case "RUNNING":
+		case "RUNNING_BUILDING":
+			status_callback({
+				status: "running",
+				load_status: "complete",
+				message: "Space is running.",
+				detail: stage
+			});
+			break;
+		case "BUILDING":
+			status_callback({
+				status: "building",
+				load_status: "pending",
+				message: "Space is building...",
+				detail: stage
+			});
+
+			setTimeout(() => {
+				check_space_status(id, type, status_callback);
+			}, 1000);
+			break;
+		case "APP_STARTING":
+			status_callback({
+				status: "starting",
+				load_status: "pending",
+				message: "Space is starting...",
+				detail: stage
+			});
+
+			setTimeout(() => {
+				check_space_status(id, type, status_callback);
+			}, 1000);
+			break;
+		default:
+			status_callback({
+				status: "space_error",
+				load_status: "error",
+				message: "This space is experiencing an issue.",
+				detail: stage,
+				discussions_enabled: await discussions_enabled(space_name)
+			});
+			break;
+	}
+}
+
+export const check_and_wake_space = async (
+	space_id: string,
+	status_callback: SpaceStatusCallback
+): Promise<void> => {
+	let retries = 0;
+	const max_retries = 12;
+	const check_interval = 5000;
+
+	return new Promise((resolve) => {
+		check_space_status(
+			space_id,
+			RE_SPACE_NAME.test(space_id) ? "space_name" : "subdomain",
+			(status) => {
+				status_callback(status);
+
+				if (status.status === "running") {
+					resolve();
+				} else if (
+					status.status === "error" ||
+					status.status === "paused" ||
+					status.status === "space_error"
+				) {
+					resolve();
+				} else if (
+					status.status === "sleeping" ||
+					status.status === "building"
+				) {
+					if (retries < max_retries) {
+						retries++;
+						setTimeout(() => {
+							check_and_wake_space(space_id, status_callback).then(resolve);
+						}, check_interval);
+					} else {
+						resolve();
+					}
+				}
+			}
+		);
+	});
+};
+
+const RE_DISABLED_DISCUSSION =
+	/^(?=[^]*\b[dD]iscussions{0,1}\b)(?=[^]*\b[dD]isabled\b)[^]*$/;
+export async function discussions_enabled(space_id: string): Promise<boolean> {
+	try {
+		const r = await fetch(
+			`https://huggingface.co/api/spaces/${space_id}/discussions`,
+			{
+				method: "HEAD"
+			}
+		);
+
+		const error = r.headers.get("x-error-message");
+
+		if (!r.ok || (error && RE_DISABLED_DISCUSSION.test(error))) return false;
+		return true;
+	} catch (e) {
+		return false;
+	}
+}
+
+export async function get_space_hardware(
+	space_id: string,
+	hf_token?: `hf_${string}` | undefined
+): Promise<(typeof hardware_types)[number]> {
+	const headers: { Authorization?: string } = {};
+	if (hf_token) {
+		headers.Authorization = `Bearer ${hf_token}`;
+	}
+
+	try {
+		const res = await fetch(
+			`https://huggingface.co/api/spaces/${space_id}/${RUNTIME_URL}`,
+			{ headers }
+		);
+
+		if (res.status !== 200)
+			throw new Error("Space hardware could not be obtained.");
+
+		const { hardware } = await res.json();
+
+		return hardware.current;
+	} catch (e: any) {
+		throw new Error(e.message);
+	}
+}
+
+export async function set_space_timeout(
+	space_id: string,
+	timeout: number,
+	hf_token?: `hf_${string}`
+): Promise<any> {
+	const headers: { Authorization?: string } = {};
+	if (hf_token) {
+		headers.Authorization = `Bearer ${hf_token}`;
+	}
+
+	const body: {
+		seconds?: number;
+	} = {
+		seconds: timeout
+	};
+
+	try {
+		const res = await fetch(
+			`https://huggingface.co/api/spaces/${space_id}/${SLEEPTIME_URL}`,
+			{
+				method: "POST",
+				headers: { "Content-Type": "application/json", ...headers },
+				body: JSON.stringify(body)
+			}
+		);
+
+		if (res.status !== 200) {
+			throw new Error(
+				"Could not set sleep timeout on duplicated Space. Please visit *ADD HF LINK TO SETTINGS* to set a timeout manually to reduce billing charges."
+			);
+		}
+
+		const response = await res.json();
+		return response;
+	} catch (e: any) {
+		throw new Error(e.message);
+	}
+}
+
+export const hardware_types = [
+	"cpu-basic",
+	"cpu-upgrade",
+	"cpu-xl",
+	"t4-small",
+	"t4-medium",
+	"a10g-small",
+	"a10g-large",
+	"a10g-largex2",
+	"a10g-largex4",
+	"a100-large",
+	"zero-a10g",
+	"h100",
+	"h100x8"
+] as const;

5.49.1/client/src/index.ts

@@ -0,0 +1,25 @@
+export { Client } from "./client";
+
+export { predict } from "./utils/predict";
+export { submit } from "./utils/submit";
+export { upload_files } from "./utils/upload_files";
+export { FileData, upload, prepare_files } from "./upload";
+export { handle_file } from "./helpers/data";
+
+export type {
+	SpaceStatus,
+	StatusMessage,
+	Status,
+	client_return,
+	UploadResponse,
+	RenderMessage,
+	LogMessage,
+	Payload,
+	Config
+} from "./types";
+
+export { MISSING_CREDENTIALS_MSG } from "./constants";
+
+// todo: remove in @gradio/client v1.0
+export { client } from "./client";
+export { duplicate_space as duplicate } from "./client";

5.49.1/client/src/test/handlers.ts

@@ -0,0 +1,693 @@
+import { HttpResponse, http, RequestHandler } from "msw";
+import {
+	HOST_URL,
+	API_INFO_URL,
+	CONFIG_URL,
+	RUNTIME_URL,
+	SLEEPTIME_URL,
+	UPLOAD_URL,
+	BROKEN_CONNECTION_MSG,
+	LOGIN_URL
+} from "../constants";
+import {
+	response_api_info,
+	config_response,
+	whoami_response,
+	duplicate_response,
+	hardware_sleeptime_response,
+	discussions_response,
+	runtime_response
+} from "./test_data";
+
+const root_url = "https://huggingface.co";
+
+export const direct_space_url = "https://hmb-hello-world.hf.space";
+const private_space_url = "https://hmb-secret-world.hf.space";
+const private_auth_space_url = "https://hmb-private-auth-space.hf.space";
+
+const server_error_space_url = "https://hmb-server-error.hf.space";
+const upload_server_test_space_url = "https://hmb-server-test.hf.space";
+const auth_app_space_url = "https://hmb-auth-space.hf.space";
+const unauth_app_space_url = "https://hmb-unauth-space.hf.space";
+const invalid_auth_space_url = "https://hmb-invalid-auth-space.hf.space";
+
+const server_error_reference = "hmb/server_error";
+const app_reference = "hmb/hello_world";
+const broken_app_reference = "hmb/bye_world";
+const duplicate_app_reference = "gradio/hello_world";
+const private_app_reference = "hmb/secret_world";
+const server_test_app_reference = "hmb/server_test";
+const auth_app_reference = "hmb/auth_space";
+const unauth_app_reference = "hmb/unauth_space";
+const invalid_auth_app_reference = "hmb/invalid_auth_space";
+const private_auth_app_reference = "hmb/private_auth_space";
+
+export const handlers: RequestHandler[] = [
+	// /host requests
+	http.get(`${root_url}/api/spaces/${app_reference}/${HOST_URL}`, () => {
+		return new HttpResponse(
+			JSON.stringify({
+				subdomain: "hmb-hello-world",
+				host: "https://hmb-hello-world.hf.space"
+			}),
+			{
+				status: 200,
+				headers: {
+					"Content-Type": "application/json"
+				}
+			}
+		);
+	}),
+	http.get(`${root_url}/api/spaces/${broken_app_reference}/${HOST_URL}`, () => {
+		return new HttpResponse(null, {
+			status: 404,
+			headers: {
+				"Content-Type": "application/json",
+				hf_token: "hf_123"
+			}
+		});
+	}),
+	http.get(
+		`${root_url}/api/spaces/${private_auth_app_reference}/${HOST_URL}`,
+		() => {
+			return new HttpResponse(
+				JSON.stringify({
+					subdomain: "hmb-private-auth-space",
+					host: "https://hmb-private-auth-space.hf.space"
+				}),
+				{
+					status: 200,
+					headers: {
+						"Content-Type": "application/json"
+					}
+				}
+			);
+		}
+	),
+	http.get(
+		`${root_url}/api/spaces/${private_app_reference}/${HOST_URL}`,
+		({ request }) => {
+			const token = request.headers.get("authorization")?.substring(7);
+
+			if (!token || token !== "hf_123") {
+				return new HttpResponse(null, {
+					status: 401,
+					headers: {
+						"Content-Type": "application/json"
+					}
+				});
+			}
+
+			return new HttpResponse(
+				JSON.stringify({
+					subdomain: private_app_reference,
+					host: private_space_url
+				}),
+				{
+					status: 200,
+					headers: {
+						"Content-Type": "application/json"
+					}
+				}
+			);
+		}
+	),
+	http.get(
+		`${root_url}/api/spaces/${server_error_reference}/${HOST_URL}`,
+		() => {
+			return new HttpResponse(
+				JSON.stringify({
+					subdomain: "hmb-server-test",
+					host: "https://hmb-server-test.hf.space"
+				}),
+				{
+					status: 200,
+					headers: {
+						"Content-Type": "application/json"
+					}
+				}
+			);
+		}
+	),
+	http.get(
+		`${root_url}/api/spaces/${server_test_app_reference}/${HOST_URL}`,
+		() => {
+			return new HttpResponse(
+				JSON.stringify({
+					subdomain: "hmb-server-test",
+					host: "https://hmb-server-test.hf.space"
+				}),
+				{
+					status: 200,
+					headers: {
+						"Content-Type": "application/json"
+					}
+				}
+			);
+		}
+	),
+	http.get(`${root_url}/api/spaces/${auth_app_reference}/${HOST_URL}`, () => {
+		return new HttpResponse(
+			JSON.stringify({
+				subdomain: "hmb-auth-space",
+				host: "https://hmb-auth-space.hf.space"
+			}),
+			{
+				status: 200,
+				headers: {
+					"Content-Type": "application/json"
+				}
+			}
+		);
+	}),
+	http.get(
+		`${root_url}/api/spaces/${invalid_auth_app_reference}/${HOST_URL}`,
+		() => {
+			return new HttpResponse(
+				JSON.stringify({
+					subdomain: "hmb-invalid-auth-space",
+					host: "https://hmb-invalid-auth-space.hf.space"
+				}),
+				{
+					status: 200,
+					headers: {
+						"Content-Type": "application/json"
+					}
+				}
+			);
+		}
+	),
+	http.get(
+		`${root_url}/api/spaces/${duplicate_app_reference}/${HOST_URL}`,
+		() => {
+			return new HttpResponse(
+				JSON.stringify({
+					subdomain: "gradio-hello-world",
+					host: "https://gradio-hello-world.hf.space"
+				}),
+				{
+					status: 200,
+					headers: {
+						"Content-Type": "application/json"
+					}
+				}
+			);
+		}
+	),
+	http.get(`${root_url}/api/spaces/${unauth_app_reference}/${HOST_URL}`, () => {
+		return new HttpResponse(
+			JSON.stringify({
+				subdomain: "hmb-unath-space",
+				host: "https://hmb-unauth-space.hf.space"
+			}),
+			{
+				status: 200,
+				headers: {
+					"Content-Type": "application/json"
+				}
+			}
+		);
+	}),
+	// /info requests
+	http.get(`${direct_space_url}/${API_INFO_URL}`, () => {
+		return new HttpResponse(JSON.stringify(response_api_info), {
+			status: 200,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	http.get(`${upload_server_test_space_url}/${API_INFO_URL}`, () => {
+		return new HttpResponse(JSON.stringify(response_api_info), {
+			status: 200,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	http.get(`${private_space_url}/${API_INFO_URL}`, () => {
+		return new HttpResponse(JSON.stringify(response_api_info), {
+			status: 200,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	http.get(`${server_error_space_url}/${API_INFO_URL}`, () => {
+		return new HttpResponse(JSON.stringify(response_api_info), {
+			status: 200,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	http.get(`${auth_app_space_url}/${API_INFO_URL}`, async () => {
+		return new HttpResponse(JSON.stringify(response_api_info), {
+			status: 200,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	http.get(`${private_auth_space_url}/${API_INFO_URL}`, async () => {
+		return new HttpResponse(JSON.stringify(response_api_info), {
+			status: 200,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	// /config requests
+	http.get(`${direct_space_url}/${CONFIG_URL}`, () => {
+		return new HttpResponse(JSON.stringify(config_response), {
+			status: 200,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	http.get(`${private_space_url}/${CONFIG_URL}`, () => {
+		return new HttpResponse(
+			JSON.stringify({
+				...config_response,
+				root: "https://hmb-secret-world.hf.space"
+			}),
+			{
+				status: 200,
+				headers: {
+					"Content-Type": "application/json"
+				}
+			}
+		);
+	}),
+	http.get(`${upload_server_test_space_url}/${CONFIG_URL}`, () => {
+		return new HttpResponse(
+			JSON.stringify({
+				...config_response,
+				root: "https://hmb-server-test.hf.space"
+			}),
+			{
+				status: 200,
+				headers: {
+					"Content-Type": "application/json"
+				}
+			}
+		);
+	}),
+	http.get(`${private_auth_space_url}/${CONFIG_URL}`, () => {
+		return new HttpResponse(
+			JSON.stringify({
+				...config_response,
+				root: "https://hmb-private-auth-space.hf.space"
+			}),
+			{
+				status: 200,
+				headers: {
+					"Content-Type": "application/json"
+				}
+			}
+		);
+	}),
+	http.get(`${direct_space_url}/${CONFIG_URL}`, () => {
+		return new HttpResponse(JSON.stringify(config_response), {
+			status: 500,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	http.get(`${server_error_space_url}/${CONFIG_URL}`, () => {
+		return new HttpResponse(JSON.stringify(config_response), {
+			status: 200,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	http.get(`${invalid_auth_space_url}/${CONFIG_URL}`, () => {
+		return new HttpResponse(JSON.stringify({ detail: "Unauthorized" }), {
+			status: 401,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	http.get(`${auth_app_space_url}/${CONFIG_URL}`, ({ request }) => {
+		return new HttpResponse(
+			JSON.stringify({
+				...config_response,
+				root: "https://hmb-auth-space.hf.space",
+				space_id: "hmb/auth_space"
+			}),
+			{
+				status: 200,
+				headers: {
+					"Content-Type": "application/json"
+				}
+			}
+		);
+	}),
+	http.get(`${unauth_app_space_url}/${CONFIG_URL}`, () => {
+		return new HttpResponse(
+			JSON.stringify({
+				detail: "Unauthorized"
+			}),
+			{
+				status: 401,
+				headers: {
+					"Content-Type": "application/json"
+				}
+			}
+		);
+	}),
+	// /whoami requests
+	http.get(`${root_url}/api/whoami-v2`, () => {
+		return new HttpResponse(JSON.stringify(whoami_response), {
+			status: 200,
+			headers: {
+				"Content-Type": "application/json",
+				"hf-token": "hf_123"
+			}
+		});
+	}),
+	// /duplicate requests
+	http.post(
+		`${root_url}/api/spaces/${duplicate_app_reference}/duplicate`,
+		({ request }) => {
+			if (request.headers.get("authorization")?.substring(7) !== "hf_123") {
+				throw new HttpResponse(null, {
+					status: 401,
+					headers: {
+						"Content-Type": "application/json"
+					}
+				});
+			}
+			return new HttpResponse(JSON.stringify(duplicate_response), {
+				status: 200,
+				headers: {
+					"Content-Type": "application/json"
+				}
+			});
+		}
+	),
+	// /sleeptime requests
+	http.post(`${root_url}/api/spaces/${app_reference}/${SLEEPTIME_URL}`, () => {
+		return new HttpResponse(JSON.stringify(hardware_sleeptime_response), {
+			status: 200,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	http.post(
+		`${root_url}/api/spaces/${server_test_app_reference}/${SLEEPTIME_URL}`,
+		() => {
+			throw new HttpResponse(null, {
+				status: 500,
+				headers: {
+					"Content-Type": "application/json"
+				}
+			});
+		}
+	),
+	// /runtime requests
+	http.get(
+		`${root_url}/api/spaces/${broken_app_reference}/${RUNTIME_URL}`,
+		() => {
+			return new HttpResponse(null, {
+				status: 404,
+				headers: {
+					"Content-Type": "application/json"
+				}
+			});
+		}
+	),
+	http.get(`${root_url}/api/spaces/${app_reference}/${RUNTIME_URL}`, () => {
+		return new HttpResponse(JSON.stringify(hardware_sleeptime_response), {
+			status: 200,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	// queue requests
+	http.get(`${direct_space_url}/queue/data`, () => {
+		return new HttpResponse(JSON.stringify({ event_id: "123" }), {
+			status: 200,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	http.post(`${direct_space_url}/queue/join`, () => {
+		return new HttpResponse(JSON.stringify({ event_id: "123" }), {
+			status: 200,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	// upload requests
+	http.post(`${direct_space_url}/${UPLOAD_URL}`, () => {
+		return new HttpResponse(JSON.stringify(["lion.jpg"]), {
+			status: 200,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	http.post(`${upload_server_test_space_url}/${UPLOAD_URL}`, () => {
+		throw new HttpResponse(JSON.parse("Internal Server Error"), {
+			status: 200,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	// discussions requests
+	http.head(`${root_url}/api/spaces/${app_reference}/discussions`, () => {
+		return new HttpResponse(JSON.stringify(discussions_response), {
+			status: 200,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	http.head(
+		`${root_url}/api/spaces/${broken_app_reference}/discussions`,
+		() => {
+			throw new HttpResponse(
+				JSON.parse("Discussions are disabled for this repo"),
+				{
+					status: 403,
+					headers: {
+						"Content-Type": "application/json"
+					}
+				}
+			);
+		}
+	),
+	// space requests
+	http.get(`${root_url}/api/spaces/${app_reference}`, () => {
+		return new HttpResponse(
+			JSON.stringify({ id: app_reference, runtime: runtime_response }),
+			{
+				status: 200,
+				headers: {
+					"Content-Type": "application/json"
+				}
+			}
+		);
+	}),
+	http.get(`${root_url}/api/spaces/hmb/paused_space`, () => {
+		return new HttpResponse(
+			JSON.stringify({
+				id: app_reference,
+				runtime: { ...runtime_response, stage: "PAUSED" }
+			}),
+			{
+				status: 200,
+				headers: {
+					"Content-Type": "application/json"
+				}
+			}
+		);
+	}),
+	http.get(`${root_url}/api/spaces/hmb/building_space`, () => {
+		return new HttpResponse(
+			JSON.stringify({
+				id: app_reference,
+				runtime: { ...runtime_response, stage: "BUILDING" }
+			}),
+			{
+				status: 200,
+				headers: {
+					"Content-Type": "application/json"
+				}
+			}
+		);
+	}),
+	http.get(`${root_url}/api/spaces/hmb/stopped_space`, () => {
+		return new HttpResponse(
+			JSON.stringify({
+				id: app_reference,
+				runtime: { ...runtime_response, stage: "STOPPED" }
+			}),
+			{
+				status: 200,
+				headers: {
+					"Content-Type": "application/json"
+				}
+			}
+		);
+	}),
+	http.get(`${root_url}/api/spaces/hmb/failed_space`, () => {
+		throw new HttpResponse(null, {
+			status: 500,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	http.get(`${root_url}/api/spaces/${unauth_app_reference}`, () => {
+		return new HttpResponse(
+			JSON.stringify({
+				id: unauth_app_reference,
+				runtime: { ...runtime_response }
+			}),
+			{
+				status: 200,
+				headers: {
+					"Content-Type": "application/json"
+				}
+			}
+		);
+	}),
+	// jwt requests
+	http.get(`${root_url}/api/spaces/${app_reference}/jwt`, () => {
+		return new HttpResponse(
+			JSON.stringify({
+				token: "jwt_123"
+			}),
+			{
+				status: 200,
+				headers: {
+					"Content-Type": "application/json"
+				}
+			}
+		);
+	}),
+	http.get(`${root_url}/api/spaces/${broken_app_reference}/jwt`, () => {
+		return new HttpResponse(null, {
+			status: 500,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	// post_data requests
+	http.post(`${direct_space_url}`, () => {
+		return new HttpResponse(JSON.stringify({}), {
+			status: 200,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	http.post(`${private_space_url}`, () => {
+		return new HttpResponse(JSON.stringify(BROKEN_CONNECTION_MSG), {
+			status: 500,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	// heartbeat requests
+	http.get(`*/heartbeat/*`, () => {
+		return new HttpResponse(null, {
+			status: 200,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	// login requests
+	http.post(`${auth_app_space_url}/${LOGIN_URL}`, async ({ request }) => {
+		let username;
+		let password;
+
+		await request.formData().then((data) => {
+			username = data.get("username");
+			password = data.get("password");
+		});
+
+		if (username === "admin" && password === "pass1234") {
+			return new HttpResponse(
+				JSON.stringify({
+					success: true
+				}),
+				{
+					status: 200,
+					headers: {
+						"Content-Type": "application/json",
+						"Set-Cookie":
+							"access-token-123=abc; HttpOnly; Path=/; SameSite=none; Secure",
+						// @ts-ignore - multiple Set-Cookie headers are returned
+						"Set-Cookie":
+							"access-token-unsecure-123=abc; HttpOnly; Path=/; SameSite=none; Secure"
+					}
+				}
+			);
+		}
+
+		return new HttpResponse(null, {
+			status: 401,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	http.post(`${invalid_auth_space_url}/${LOGIN_URL}`, async () => {
+		return new HttpResponse(null, {
+			status: 401,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	}),
+	http.post(`${private_auth_space_url}/${LOGIN_URL}`, async ({ request }) => {
+		let username;
+		let password;
+
+		await request.formData().then((data) => {
+			username = data.get("username");
+			password = data.get("password");
+		});
+
+		if (username === "admin" && password === "pass1234") {
+			return new HttpResponse(
+				JSON.stringify({
+					success: true
+				}),
+				{
+					status: 200,
+					headers: {
+						"Content-Type": "application/json",
+						"Set-Cookie":
+							"access-token-123=abc; HttpOnly; Path=/; SameSite=none; Secure",
+						// @ts-ignore - multiple Set-Cookie headers are returned
+						"Set-Cookie":
+							"access-token-unsecure-123=abc; HttpOnly; Path=/; SameSite=none; Secure"
+					}
+				}
+			);
+		}
+
+		return new HttpResponse(null, {
+			status: 401,
+			headers: {
+				"Content-Type": "application/json"
+			}
+		});
+	})
+];

5.49.1/client/src/test/mock_eventsource.ts

@@ -0,0 +1,13 @@
+import { vi } from "vitest";
+
+if (process.env.TEST_MODE !== "node") {
+	Object.defineProperty(window, "EventSource", {
+		writable: true,
+		value: vi.fn().mockImplementation(() => ({
+			close: vi.fn(() => {}),
+			addEventListener: vi.fn(),
+			onmessage: vi.fn((_event: MessageEvent) => {}),
+			onerror: vi.fn((_event: Event) => {})
+		}))
+	});
+}

5.49.1/client/src/test/server.ts

@@ -0,0 +1,6 @@
+import { setupServer } from "msw/node";
+import { handlers } from "./handlers";
+
+export function initialise_server(): any {
+	return setupServer(...handlers);
+}

5.49.1/client/src/test/test_data.ts

@@ -0,0 +1,562 @@
+// @ts-nocheck
+import { ApiData, ApiInfo, Config, EndpointInfo } from "../types";
+
+export const runtime_response = {
+	stage: "RUNNING",
+	hardware: {
+		current: "cpu-basic",
+		requested: "cpu-basic"
+	},
+	storage: {
+		current: null,
+		requested: null
+	},
+	gcTimeout: 86400,
+	replicas: {
+		current: 1,
+		requested: 1
+	},
+	devMode: false,
+	domains: [
+		{
+			domain: "hmb-hello-world.hf.space",
+			isCustom: false,
+			stage: "READY"
+		}
+	]
+};
+
+export const transformed_api_info: ApiInfo<ApiData> = {
+	named_endpoints: {
+		"/predict": {
+			parameters: [
+				{
+					label: "name",
+					type: "string",
+					python_type: { type: "str", description: "" },
+					component: "Textbox",
+					example_input: "Hello!!"
+				}
+			],
+			returns: [
+				{
+					label: "output",
+					type: "string",
+					python_type: { type: "str", description: "" },
+					component: "Textbox"
+				}
+			],
+			type: { generator: false, cancel: false }
+		}
+	},
+	unnamed_endpoints: {
+		"0": {
+			parameters: [
+				{
+					label: "name",
+					type: "string",
+					python_type: { type: "str", description: "" },
+					component: "Textbox",
+					example_input: "Hello!!"
+				}
+			],
+			returns: [
+				{
+					label: "output",
+					type: "string",
+					python_type: { type: "str", description: "" },
+					component: "Textbox"
+				}
+			],
+			type: { generator: false, cancel: false }
+		}
+	}
+};
+
+export const response_api_info: ApiInfo<ApiData> = {
+	named_endpoints: {
+		"/predict": {
+			parameters: [
+				{
+					label: "name",
+					type: {
+						type: "string"
+					},
+					python_type: {
+						type: "str",
+						description: ""
+					},
+					component: "Textbox",
+					example_input: "Hello!!"
+				}
+			],
+			returns: [
+				{
+					label: "output",
+					type: {
+						type: "string"
+					},
+					python_type: {
+						type: "str",
+						description: ""
+					},
+					component: "Textbox"
+				}
+			]
+		}
+	},
+	unnamed_endpoints: {}
+};
+
+export const config_response: Config = {
+	version: "4.27.0",
+	mode: "interface",
+	app_id: 123,
+	dev_mode: false,
+	analytics_enabled: true,
+	components: [
+		{
+			id: 3,
+			type: "row",
+			props: {
+				variant: "default",
+				visible: true,
+				equal_height: false,
+				name: "row"
+			},
+			skip_api: true,
+			component_class_id: ""
+		},
+		{
+			id: 4,
+			type: "column",
+			props: {
+				scale: 1,
+				min_width: 320,
+				variant: "panel",
+				visible: true,
+				name: "column"
+			},
+			skip_api: true,
+			component_class_id: ""
+		},
+		{
+			id: 5,
+			type: "column",
+			props: {
+				scale: 1,
+				min_width: 320,
+				variant: "default",
+				visible: true,
+				name: "column"
+			},
+			skip_api: true,
+			component_class_id: ""
+		},
+		{
+			id: 1,
+			type: "textbox",
+			props: {
+				lines: 1,
+				max_lines: 20,
+				label: "name",
+				show_label: true,
+				container: true,
+				min_width: 160,
+				visible: true,
+				autofocus: false,
+				autoscroll: true,
+				elem_classes: [],
+				type: "text",
+				rtl: false,
+				show_copy_button: false,
+				name: "textbox",
+				_selectable: false
+			},
+			skip_api: false,
+			component_class_id: "",
+			api_info: {
+				type: "string"
+			},
+			example_inputs: "Hello!!"
+		},
+		{
+			id: 6,
+			type: "form",
+			props: {
+				scale: 0,
+				min_width: 0,
+				name: "form"
+			},
+			skip_api: true,
+			component_class_id: ""
+		},
+		{
+			id: 7,
+			type: "row",
+			props: {
+				variant: "default",
+				visible: true,
+				equal_height: true,
+				name: "row"
+			},
+			skip_api: true,
+			component_class_id: ""
+		},
+		{
+			id: 8,
+			type: "button",
+			props: {
+				value: "Clear",
+				variant: "secondary",
+				visible: true,
+				interactive: true,
+				elem_classes: [],
+				show_api: false,
+				name: "button",
+				_selectable: false
+			},
+			skip_api: true,
+			component_class_id: ""
+		},
+		{
+			id: 9,
+			type: "button",
+			props: {
+				value: "Submit",
+				variant: "primary",
+				visible: true,
+				interactive: true,
+				elem_classes: [],
+				name: "button",
+				_selectable: false
+			},
+			skip_api: true,
+			component_class_id: ""
+		},
+		{
+			id: 10,
+			type: "column",
+			props: {
+				scale: 1,
+				min_width: 320,
+				variant: "panel",
+				visible: true,
+				name: "column"
+			},
+			skip_api: true,
+			component_class_id: ""
+		},
+		{
+			id: 2,
+			type: "textbox",
+			props: {
+				lines: 1,
+				max_lines: 20,
+				label: "output",
+				show_label: true,
+				container: true,
+				min_width: 160,
+				interactive: false,
+				visible: true,
+				autofocus: false,
+				autoscroll: true,
+				elem_classes: [],
+				type: "text",
+				rtl: false,
+				show_copy_button: false,
+				name: "textbox",
+				_selectable: false
+			},
+			skip_api: false,
+			component_class_id: "",
+			api_info: {
+				type: "string"
+			},
+			example_inputs: "Hello!!"
+		},
+		{
+			id: 11,
+			type: "row",
+			props: {
+				variant: "default",
+				visible: true,
+				equal_height: true,
+				name: "row"
+			},
+			skip_api: true,
+			component_class_id: ""
+		},
+		{
+			id: 12,
+			type: "form",
+			props: {
+				scale: 0,
+				min_width: 0,
+				name: "form"
+			},
+			skip_api: true,
+			component_class_id: ""
+		}
+	],
+	css: null,
+	js: null,
+	head: null,
+	title: "Gradio",
+	space_id: "hmb/hello_world",
+	enable_queue: true,
+	show_error: false,
+	show_api: true,
+	is_colab: false,
+	stylesheets: [],
+	theme: "default",
+	protocol: "sse_v3",
+	body_css: {
+		body_background_fill: "white",
+		body_text_color: "#1f2937",
+		body_background_fill_dark: "#0b0f19",
+		body_text_color_dark: "#f3f4f6"
+	},
+	fill_height: false,
+	layout: {
+		id: 0,
+		children: [
+			{
+				id: 3,
+				children: [
+					{
+						id: 4,
+						children: [
+							{
+								id: 5,
+								children: [
+									{
+										id: 6,
+										children: [
+											{
+												id: 1
+											}
+										]
+									}
+								]
+							},
+							{
+								id: 7,
+								children: [
+									{
+										id: 8
+									},
+									{
+										id: 9
+									}
+								]
+							}
+						]
+					},
+					{
+						id: 10,
+						children: [
+							{
+								id: 12,
+								children: [
+									{
+										id: 2
+									}
+								]
+							},
+							{
+								id: 11,
+								children: []
+							}
+						]
+					}
+				]
+			}
+		]
+	},
+	dependencies: [
+		{
+			id: 0,
+			targets: [
+				[9, "click"],
+				[1, "submit"]
+			],
+			inputs: [1],
+			outputs: [2],
+			backend_fn: true,
+			js: null,
+			queue: null,
+			api_name: "predict",
+			scroll_to_output: false,
+			show_progress: "full",
+			every: null,
+			batch: false,
+			max_batch_size: 4,
+			cancels: [],
+			types: {
+				generator: false,
+				cancel: false
+			},
+			collects_event_data: false,
+			trigger_after: null,
+			trigger_only_on_success: false,
+			trigger_only_on_failure: false,
+			trigger_mode: "once",
+			show_api: true,
+			zerogpu: false
+		},
+		{
+			id: 1,
+			targets: [[8, "click"]],
+			inputs: [],
+			outputs: [1, 2],
+			backend_fn: false,
+			js: "() => [null, null]",
+			queue: false,
+			api_name: "js_fn",
+			scroll_to_output: false,
+			show_progress: "full",
+			every: null,
+			batch: false,
+			max_batch_size: 4,
+			cancels: [],
+			types: {
+				generator: false,
+				cancel: false
+			},
+			collects_event_data: false,
+			trigger_after: null,
+			trigger_only_on_success: false,
+			trigger_only_on_failure: false,
+			trigger_mode: "once",
+			show_api: false,
+			zerogpu: false
+		},
+		{
+			id: 2,
+			targets: [[8, "click"]],
+			inputs: [],
+			outputs: [5],
+			backend_fn: false,
+			js: '() => [{"variant": null, "visible": true, "__type__": "update"}]\n            ',
+			queue: false,
+			api_name: "js_fn_1",
+			scroll_to_output: false,
+			show_progress: "full",
+			every: null,
+			batch: false,
+			max_batch_size: 4,
+			cancels: [],
+			types: {
+				generator: false,
+				cancel: false
+			},
+			collects_event_data: false,
+			trigger_after: null,
+			trigger_only_on_success: false,
+			trigger_only_on_failure: false,
+			trigger_mode: "once",
+			show_api: false,
+			zerogpu: false
+		}
+	],
+	root: "https://hmb-hello-world.hf.space",
+	path: ""
+};
+
+export const whoami_response = {
+	type: "user",
+	id: "123",
+	name: "hmb",
+	fullname: "jerry",
+	email: "[email protected]",
+	emailVerified: true,
+	canPay: true,
+	periodEnd: 123,
+	isPro: false,
+	avatarUrl: "",
+	orgs: [],
+	auth: {
+		type: "access_token",
+		accessToken: {
+			displayName: "Gradio Client",
+			role: "write"
+		}
+	}
+};
+
+export const duplicate_response = {
+	url: "https://huggingface.co/spaces/hmb/hello_world"
+};
+
+export const hardware_sleeptime_response = {
+	stage: "RUNNING",
+	hardware: {
+		current: "cpu-basic",
+		requested: "cpu-upgrade"
+	},
+	storage: null,
+	gcTimeout: 300,
+	replicas: {
+		current: 1,
+		requested: 1
+	},
+	devMode: false,
+	domains: [
+		{
+			domain: "hmb-hello-world.hf.space",
+			isCustom: false,
+			stage: "READY"
+		}
+	]
+};
+
+export const endpoint_info: EndpointInfo<ApiData> = {
+	parameters: [
+		{
+			label: "parameter_2",
+			parameter_name: "im",
+			parameter_has_default: false,
+			parameter_default: null,
+			type: "",
+			python_type: {
+				type: "Dict(background: filepath | None, layers: List[filepath], composite: filepath | None, id: str | None)",
+				description: ""
+			},
+			component: "Imageeditor",
+			example_input: {
+				background: {
+					path: "",
+					meta: {
+						_type: "gradio.FileData"
+					},
+					orig_name: "bus.png",
+					url: ""
+				},
+				layers: [],
+				composite: null
+			}
+		}
+	],
+	returns: [
+		{
+			label: "value_3",
+			type: "string",
+			python_type: {
+				type: "filepath",
+				description: ""
+			},
+			component: "Image"
+		}
+	],
+	type: {
+		generator: false
+	}
+};
+
+export const discussions_response = {
+	discussions: [],
+	count: 0,
+	start: 0,
+	numClosedDiscussions: 0
+};

5.49.1/client/src/types.ts

@@ -0,0 +1,422 @@
+// API Data Types
+
+import { hardware_types } from "./helpers/spaces";
+import type { SvelteComponent } from "svelte";
+import type { ComponentType } from "svelte";
+
+export interface ApiData {
+	label: string;
+	parameter_name: string;
+	parameter_default?: any;
+	parameter_has_default?: boolean;
+	type: {
+		type: any;
+		description: string;
+	};
+	component: string;
+	example_input?: any;
+	python_type: { type: string; description: string };
+	serializer: string;
+}
+
+export interface JsApiData {
+	label: string;
+	parameter_name: string;
+	parameter_default?: any;
+	parameter_has_default?: boolean;
+	type: string;
+	description: string;
+	component: string;
+	example_input?: any;
+	serializer: string;
+	python_type: { type: string; description: string };
+}
+
+export interface EndpointInfo<T extends ApiData | JsApiData> {
+	parameters: T[];
+	returns: T[];
+	type?: DependencyTypes;
+}
+
+export interface ApiInfo<T extends ApiData | JsApiData> {
+	named_endpoints: Record<string, EndpointInfo<T>>;
+	unnamed_endpoints: Record<string, EndpointInfo<T>>;
+}
+
+export interface BlobRef {
+	path: string[];
+	type: string | undefined;
+	blob: Blob | File | false;
+}
+
+export type DataType = string | Buffer | Record<string, any> | any[];
+
+// custom class used for uploading local files
+export class Command {
+	type: string;
+	command: string;
+	meta: {
+		path: string;
+		name: string;
+		orig_path: string;
+	};
+	fileData?: FileData;
+
+	constructor(
+		command: string,
+		meta: { path: string; name: string; orig_path: string }
+	) {
+		this.type = "command";
+		this.command = command;
+		this.meta = meta;
+	}
+}
+
+// Function Signature Types
+
+export type SubmitFunction = (
+	endpoint: string | number,
+	data?: unknown[] | Record<string, unknown>,
+	event_data?: unknown,
+	trigger_id?: number | null
+) => SubmitIterable<GradioEvent>;
+
+export type PredictFunction = (
+	endpoint: string | number,
+	data?: unknown[] | Record<string, unknown>,
+	event_data?: unknown
+) => Promise<PredictReturn>;
+
+export type client_return = {
+	config: Config | undefined;
+	predict: PredictFunction;
+	submit: SubmitFunction;
+	component_server: (
+		component_id: number,
+		fn_name: string,
+		data: unknown[]
+	) => any;
+	view_api: (_fetch: typeof fetch) => Promise<ApiInfo<JsApiData>>;
+};
+
+export interface SubmitIterable<T> extends AsyncIterable<T> {
+	[Symbol.asyncIterator](): AsyncIterator<T>;
+	cancel: () => Promise<void>;
+	event_id: () => string;
+}
+
+export type PredictReturn = {
+	type: EventType;
+	time: Date;
+	data: unknown;
+	endpoint: string;
+	fn_index: number;
+};
+
+// Space Status Types
+
+export type SpaceStatus = SpaceStatusNormal | SpaceStatusError;
+
+export interface SpaceStatusNormal {
+	status:
+		| "sleeping"
+		| "running"
+		| "building"
+		| "error"
+		| "stopped"
+		| "starting";
+	detail:
+		| "SLEEPING"
+		| "RUNNING"
+		| "RUNNING_BUILDING"
+		| "BUILDING"
+		| "APP_STARTING"
+		| "NOT_FOUND";
+	load_status: "pending" | "error" | "complete" | "generating";
+	message: string;
+}
+
+export interface SpaceStatusError {
+	status: "space_error" | "paused";
+	detail:
+		| "NO_APP_FILE"
+		| "CONFIG_ERROR"
+		| "BUILD_ERROR"
+		| "RUNTIME_ERROR"
+		| "PAUSED";
+	load_status: "error";
+	message: string;
+	discussions_enabled: boolean;
+}
+
+export type SpaceStatusCallback = (a: SpaceStatus) => void;
+
+// Configuration and Response Types
+// --------------------------------
+export interface Config {
+	deep_link_state?: "none" | "valid" | "invalid";
+	auth_required?: true;
+	app_id?: string;
+	analytics_enabled: boolean;
+	connect_heartbeat: boolean;
+	dev_mode: boolean;
+	vibe_mode: boolean;
+	auth_message: string;
+	components: ComponentMeta[];
+	css: string | null;
+	js: string | null;
+	head: string | null;
+	dependencies: Dependency[];
+	enable_queue: boolean;
+	show_error: boolean;
+	layout: any;
+	mode: "blocks" | "interface";
+	root: string;
+	root_url?: string;
+	theme: string;
+	title: string;
+	version: string;
+	space_id: string | null;
+	is_space: boolean;
+	is_colab: boolean;
+	show_api: boolean;
+	stylesheets: string[];
+	current_page: string;
+	page: Record<
+		string,
+		{
+			components: number[];
+			dependencies: number[];
+			layout: any;
+		}
+	>;
+	pages: [string, string, boolean][];
+	protocol: "sse_v3" | "sse_v2.1" | "sse_v2" | "sse_v1" | "sse" | "ws";
+	max_file_size?: number;
+	theme_hash?: number;
+	username: string | null;
+	api_prefix?: string;
+	fill_height?: boolean;
+	fill_width?: boolean;
+	pwa?: boolean;
+	i18n_translations?: Record<string, Record<string, string>> | null;
+	mcp_server?: boolean;
+}
+
+// todo: DRY up types
+export interface ComponentMeta {
+	type: string;
+	id: number;
+	has_modes: boolean;
+	props: SharedProps;
+	instance: SvelteComponent;
+	component: ComponentType<SvelteComponent>;
+	documentation?: Documentation;
+	children?: ComponentMeta[];
+	parent?: ComponentMeta;
+	value?: any;
+	component_class_id: string;
+	key: string | number | null;
+	rendered_in?: number;
+}
+
+interface SharedProps {
+	elem_id?: string;
+	elem_classes?: string[];
+	components?: string[];
+	server_fns?: string[];
+	interactive: boolean;
+	visible: boolean | "hidden";
+	[key: string]: unknown;
+	root_url?: string;
+}
+
+export interface Documentation {
+	type?: TypeDescription;
+	description?: TypeDescription;
+	example_data?: string;
+}
+
+interface TypeDescription {
+	input_payload?: string;
+	response_object?: string;
+	payload?: string;
+}
+
+export interface Dependency {
+	id: number;
+	targets: [number, string][];
+	inputs: number[];
+	outputs: number[];
+	backend_fn: boolean;
+	js: string | null;
+	scroll_to_output: boolean;
+	trigger: "click" | "load" | string;
+	max_batch_size: number;
+	show_progress: "full" | "minimal" | "hidden";
+	show_progress_on: number[] | null;
+	frontend_fn: ((...args: unknown[]) => Promise<unknown[]>) | null;
+	status?: string;
+	queue: boolean | null;
+	every: number | null;
+	batch: boolean;
+	api_name: string | null;
+	cancels: number[];
+	types: DependencyTypes;
+	collects_event_data: boolean;
+	pending_request?: boolean;
+	trigger_after?: number;
+	trigger_only_on_success?: boolean;
+	trigger_only_on_failure?: boolean;
+	trigger_mode: "once" | "multiple" | "always_last";
+	final_event: Payload | null;
+	show_api: boolean;
+	rendered_in: number | null;
+	render_id: number | null;
+	connection: "stream" | "sse";
+	time_limit: number;
+	stream_every: number;
+	like_user_message: boolean;
+	event_specific_args: string[];
+	js_implementation: string | null;
+}
+
+export interface DependencyTypes {
+	generator: boolean;
+	cancel: boolean;
+}
+
+export interface Payload {
+	fn_index: number;
+	data: unknown[];
+	time?: Date;
+	event_data?: unknown;
+	trigger_id?: number | null;
+}
+
+export interface PostResponse {
+	error?: string;
+	[x: string]: any;
+}
+
+export interface UploadResponse {
+	error?: string;
+	files?: string[];
+}
+
+// Client and File Handling Types
+
+export interface DuplicateOptions extends ClientOptions {
+	private?: boolean;
+	hardware?: (typeof hardware_types)[number];
+	timeout?: number;
+}
+
+export interface ClientOptions {
+	hf_token?: `hf_${string}`;
+	status_callback?: SpaceStatusCallback | null;
+	auth?: [string, string] | null;
+	with_null_state?: boolean;
+	events?: EventType[];
+	headers?: Record<string, string>;
+	query_params?: Record<string, string>;
+	session_hash?: string;
+}
+
+export interface FileData {
+	name: string;
+	orig_name?: string;
+	size?: number;
+	data: string;
+	blob?: File;
+	is_file?: boolean;
+	mime_type?: string;
+	alt_text?: string;
+}
+
+// Event and Listener Types
+
+export type EventType = "data" | "status" | "log" | "render";
+
+export interface EventMap {
+	data: PayloadMessage;
+	status: StatusMessage;
+	log: LogMessage;
+	render: RenderMessage;
+}
+
+export type GradioEvent = {
+	[P in EventType]: EventMap[P];
+}[EventType];
+
+export interface Log {
+	log: string;
+	title: string;
+	level: "warning" | "info" | "success";
+}
+export interface Render {
+	data: {
+		components: any[];
+		layout: any;
+		dependencies: Dependency[];
+		render_id: number;
+	};
+}
+
+export interface ValidationError {
+	is_valid: boolean;
+	message: string;
+}
+
+export interface Status {
+	queue: boolean;
+	code?: string;
+	success?: boolean;
+	stage: "pending" | "error" | "complete" | "generating" | "streaming";
+	duration?: number;
+	visible?: boolean;
+	broken?: boolean;
+	size?: number;
+	position?: number;
+	eta?: number;
+	title?: string;
+	message?: string | ValidationError[];
+	progress_data?: {
+		progress: number | null;
+		index: number | null;
+		length: number | null;
+		unit: string | null;
+		desc: string | null;
+	}[];
+	time?: Date;
+	changed_state_ids?: number[];
+	time_limit?: number;
+	session_not_found?: boolean;
+}
+
+export interface StatusMessage extends Status {
+	type: "status";
+	endpoint: string;
+	fn_index: number;
+	original_msg?: string;
+}
+
+export interface PayloadMessage extends Payload {
+	type: "data";
+	endpoint: string;
+	fn_index: number;
+}
+
+export interface LogMessage extends Log {
+	type: "log";
+	endpoint: string;
+	fn_index: number;
+	duration: number | null;
+	visible: boolean;
+}
+
+export interface RenderMessage extends Render {
+	type: "render";
+	endpoint: string;
+	fn_index: number;
+}

5.49.1/client/src/upload.ts

@@ -0,0 +1,109 @@
+import type { Client } from "./client";
+
+export async function upload(
+	this: Client,
+	file_data: FileData[],
+	root_url: string,
+	upload_id?: string,
+	max_file_size?: number
+): Promise<(FileData | null)[] | null> {
+	let files = (Array.isArray(file_data) ? file_data : [file_data]).map(
+		(file_data) => file_data.blob!
+	);
+
+	const oversized_files = files.filter(
+		(f) => f.size > (max_file_size ?? Infinity)
+	);
+	if (oversized_files.length) {
+		throw new Error(
+			`File size exceeds the maximum allowed size of ${max_file_size} bytes: ${oversized_files
+				.map((f) => f.name)
+				.join(", ")}`
+		);
+	}
+
+	return await Promise.all(
+		await this.upload_files(root_url, files, upload_id).then(
+			async (response: { files?: string[]; error?: string }) => {
+				if (response.error) {
+					throw new Error(response.error);
+				} else {
+					if (response.files) {
+						return response.files.map((f, i) => {
+							const file = new FileData({
+								...file_data[i],
+								path: f,
+								url: `${root_url}${this.api_prefix}/file=${f}`
+							});
+							return file;
+						});
+					}
+
+					return [];
+				}
+			}
+		)
+	);
+}
+
+export async function prepare_files(
+	files: File[],
+	is_stream?: boolean
+): Promise<FileData[]> {
+	return files.map(
+		(f) =>
+			new FileData({
+				path: f.name,
+				orig_name: f.name,
+				blob: f,
+				size: f.size,
+				mime_type: f.type,
+				is_stream
+			})
+	);
+}
+
+export class FileData {
+	path: string;
+	url?: string;
+	orig_name?: string;
+	size?: number;
+	blob?: File;
+	is_stream?: boolean;
+	mime_type?: string;
+	alt_text?: string;
+	b64?: string;
+	readonly meta = { _type: "gradio.FileData" };
+
+	constructor({
+		path,
+		url,
+		orig_name,
+		size,
+		blob,
+		is_stream,
+		mime_type,
+		alt_text,
+		b64
+	}: {
+		path: string;
+		url?: string;
+		orig_name?: string;
+		size?: number;
+		blob?: File;
+		is_stream?: boolean;
+		mime_type?: string;
+		alt_text?: string;
+		b64?: string;
+	}) {
+		this.path = path;
+		this.url = url;
+		this.orig_name = orig_name;
+		this.size = size;
+		this.blob = url ? undefined : blob;
+		this.is_stream = is_stream;
+		this.mime_type = mime_type;
+		this.alt_text = alt_text;
+		this.b64 = b64;
+	}
+}

5.49.1/client/src/utils/duplicate.ts

@@ -0,0 +1,129 @@
+import {
+	get_space_hardware,
+	hardware_types,
+	set_space_timeout
+} from "../helpers/spaces";
+import type { DuplicateOptions } from "../types";
+import { Client } from "../client";
+import { SPACE_METADATA_ERROR_MSG } from "../constants";
+import {
+	get_cookie_header,
+	parse_and_set_cookies
+} from "../helpers/init_helpers";
+import { process_endpoint } from "../helpers/api_info";
+
+export async function duplicate(
+	app_reference: string,
+	options: DuplicateOptions
+): Promise<Client> {
+	const { hf_token, private: _private, hardware, timeout, auth } = options;
+
+	if (hardware && !hardware_types.includes(hardware)) {
+		throw new Error(
+			`Invalid hardware type provided. Valid types are: ${hardware_types
+				.map((v) => `"${v}"`)
+				.join(",")}.`
+		);
+	}
+
+	const { http_protocol, host } = await process_endpoint(
+		app_reference,
+		hf_token
+	);
+
+	let cookies: string[] | null = null;
+
+	if (auth) {
+		const cookie_header = await get_cookie_header(
+			http_protocol,
+			host,
+			auth,
+			fetch
+		);
+
+		if (cookie_header) cookies = parse_and_set_cookies(cookie_header);
+	}
+
+	const headers = {
+		Authorization: `Bearer ${hf_token}`,
+		"Content-Type": "application/json",
+		...(cookies ? { Cookie: cookies.join("; ") } : {})
+	};
+
+	const user = (
+		await (
+			await fetch(`https://huggingface.co/api/whoami-v2`, {
+				headers
+			})
+		).json()
+	).name;
+
+	const space_name = app_reference.split("/")[1];
+	const body: {
+		repository: string;
+		private?: boolean;
+		hardware?: string;
+	} = {
+		repository: `${user}/${space_name}`
+	};
+
+	if (_private) {
+		body.private = true;
+	}
+
+	let original_hardware;
+
+	try {
+		if (!hardware) {
+			original_hardware = await get_space_hardware(app_reference, hf_token);
+		}
+	} catch (e) {
+		throw Error(SPACE_METADATA_ERROR_MSG + (e as Error).message);
+	}
+
+	const requested_hardware = hardware || original_hardware || "cpu-basic";
+
+	body.hardware = requested_hardware;
+
+	try {
+		const response = await fetch(
+			`https://huggingface.co/api/spaces/${app_reference}/duplicate`,
+			{
+				method: "POST",
+				headers,
+				body: JSON.stringify(body)
+			}
+		);
+
+		if (response.status === 409) {
+			try {
+				const client = await Client.connect(`${user}/${space_name}`, options);
+				return client;
+			} catch (error) {
+				console.error("Failed to connect Client instance:", error);
+				throw error;
+			}
+		} else if (response.status !== 200) {
+			throw new Error(response.statusText);
+		}
+
+		const duplicated_space = await response.json();
+
+		await set_space_timeout(`${user}/${space_name}`, timeout || 300, hf_token);
+
+		return await Client.connect(
+			get_space_reference(duplicated_space.url),
+			options
+		);
+	} catch (e: any) {
+		throw new Error(e);
+	}
+}
+
+function get_space_reference(url: string): any {
+	const regex = /https:\/\/huggingface.co\/spaces\/([^/]+\/[^/]+)/;
+	const match = url.match(regex);
+	if (match) {
+		return match[1];
+	}
+}

5.49.1/client/src/utils/handle_blob.ts

@@ -0,0 +1,140 @@
+import { update_object, walk_and_store_blobs } from "../helpers/data";
+import {
+	Command,
+	type ApiData,
+	type EndpointInfo,
+	type JsApiData
+} from "../types";
+import { FileData } from "../upload";
+import type { Client } from "..";
+import {
+	FILE_PROCESSING_ERROR_MSG,
+	NODEJS_FS_ERROR_MSG,
+	ROOT_URL_ERROR_MSG
+} from "../constants";
+
+export async function handle_blob(
+	this: Client,
+	endpoint: string,
+	data: unknown[],
+	api_info: EndpointInfo<JsApiData | ApiData>
+): Promise<unknown[]> {
+	const self = this;
+
+	await process_local_file_commands(self, data);
+
+	const blobRefs = await walk_and_store_blobs(
+		data,
+		undefined,
+		[],
+		true,
+		api_info
+	);
+
+	const results = await Promise.all(
+		blobRefs.map(async ({ path, blob, type }) => {
+			if (!blob) return { path, type };
+
+			const response = await self.upload_files(endpoint, [blob]);
+			const file_url = response.files && response.files[0];
+			return {
+				path,
+				file_url,
+				type,
+				name:
+					typeof File !== "undefined" && blob instanceof File
+						? blob?.name
+						: undefined
+			};
+		})
+	);
+
+	results.forEach(({ path, file_url, type, name }) => {
+		if (type === "Gallery") {
+			update_object(data, file_url, path);
+		} else if (file_url) {
+			const file = new FileData({ path: file_url, orig_name: name });
+			update_object(data, file, path);
+		}
+	});
+
+	return data;
+}
+
+export async function process_local_file_commands(
+	client: Client,
+	data: unknown[]
+): Promise<void> {
+	const root = client.config?.root || client.config?.root_url;
+
+	if (!root) {
+		throw new Error(ROOT_URL_ERROR_MSG);
+	}
+
+	await recursively_process_commands(client, data);
+}
+
+async function recursively_process_commands(
+	client: Client,
+	data: any,
+	path: string[] = []
+): Promise<void> {
+	for (const key in data) {
+		if (data[key] instanceof Command) {
+			await process_single_command(client, data, key);
+		} else if (typeof data[key] === "object" && data[key] !== null) {
+			await recursively_process_commands(client, data[key], [...path, key]);
+		}
+	}
+}
+
+async function process_single_command(
+	client: Client,
+	data: any,
+	key: string
+): Promise<void> {
+	let cmd_item = data[key] as Command;
+	const root = client.config?.root || client.config?.root_url;
+
+	if (!root) {
+		throw new Error(ROOT_URL_ERROR_MSG);
+	}
+
+	try {
+		let fileBuffer: Buffer;
+		let fullPath: string;
+
+		// check if running in a Node.js environment
+		if (
+			typeof process !== "undefined" &&
+			process.versions &&
+			process.versions.node
+		) {
+			const fs = await import("fs/promises");
+			const path = await import("path");
+
+			fullPath = path.resolve(process.cwd(), cmd_item.meta.path);
+			fileBuffer = await fs.readFile(fullPath); // Read file from disk
+		} else {
+			throw new Error(NODEJS_FS_ERROR_MSG);
+		}
+
+		const file = new Blob([fileBuffer], { type: "application/octet-stream" });
+
+		const response = await client.upload_files(root, [file]);
+
+		const file_url = response.files && response.files[0];
+
+		if (file_url) {
+			const fileData = new FileData({
+				path: file_url,
+				orig_name: cmd_item.meta.name || ""
+			});
+
+			// replace the command object with the fileData object
+			data[key] = fileData;
+		}
+	} catch (error) {
+		console.error(FILE_PROCESSING_ERROR_MSG, error);
+	}
+}

5.49.1/client/src/utils/post_data.ts

@@ -0,0 +1,38 @@
+import { BROKEN_CONNECTION_MSG } from "../constants";
+import type { PostResponse } from "../types";
+import { Client } from "..";
+
+export async function post_data(
+	this: Client,
+	url: string,
+	body: unknown,
+	additional_headers?: any
+): Promise<[PostResponse, number]> {
+	const headers: {
+		Authorization?: string;
+		"Content-Type": "application/json";
+	} = { "Content-Type": "application/json" };
+	if (this.options.hf_token) {
+		headers.Authorization = `Bearer ${this.options.hf_token}`;
+	}
+	try {
+		var response = await this.fetch(url, {
+			method: "POST",
+			body: JSON.stringify(body),
+			headers: { ...headers, ...additional_headers },
+			credentials: "include"
+		});
+	} catch (e) {
+		return [{ error: BROKEN_CONNECTION_MSG }, 500];
+	}
+	let output: PostResponse;
+	let status: number;
+	try {
+		output = await response.json();
+		status = response.status;
+	} catch (e) {
+		output = { error: `Could not parse server response: ${e}` };
+		status = 500;
+	}
+	return [output, status];
+}

5.49.1/client/src/utils/predict.ts

@@ -0,0 +1,51 @@
+import { Client } from "../client";
+import type { Dependency, PredictReturn } from "../types";
+
+export async function predict(
+	this: Client,
+	endpoint: string | number,
+	data: unknown[] | Record<string, unknown> = {}
+): Promise<PredictReturn> {
+	let data_returned = false;
+	let status_complete = false;
+	let dependency: Dependency;
+
+	if (!this.config) {
+		throw new Error("Could not resolve app config");
+	}
+
+	if (typeof endpoint === "number") {
+		dependency = this.config.dependencies.find((dep) => dep.id == endpoint)!;
+	} else {
+		const trimmed_endpoint = endpoint.replace(/^\//, "");
+		dependency = this.config.dependencies.find(
+			(dep) => dep.id == this.api_map[trimmed_endpoint]
+		)!;
+	}
+
+	return new Promise(async (resolve, reject) => {
+		const app = this.submit(endpoint, data, null, null, true);
+		let result: unknown;
+
+		for await (const message of app) {
+			if (message.type === "data") {
+				if (status_complete) {
+					resolve(result as PredictReturn);
+				}
+				data_returned = true;
+				result = message;
+			}
+
+			if (message.type === "status") {
+				if (message.stage === "error") reject(message);
+				if (message.stage === "complete") {
+					status_complete = true;
+					// if complete message comes after data, resolve here
+					if (data_returned) {
+						resolve(result as PredictReturn);
+					}
+				}
+			}
+		}
+	});
+}

5.49.1/client/src/utils/stream.ts

@@ -0,0 +1,229 @@
+import { BROKEN_CONNECTION_MSG, SSE_URL } from "../constants";
+import type { Client } from "../client";
+import { stream } from "fetch-event-stream";
+
+export async function open_stream(this: Client): Promise<void> {
+	let {
+		event_callbacks,
+		unclosed_events,
+		pending_stream_messages,
+		stream_status,
+		config,
+		jwt
+	} = this;
+
+	const that = this;
+
+	if (!config) {
+		throw new Error("Could not resolve app config");
+	}
+
+	stream_status.open = true;
+
+	let stream: EventSource | null = null;
+	let params = new URLSearchParams({
+		session_hash: this.session_hash
+	}).toString();
+
+	let url = new URL(`${config.root}${this.api_prefix}/${SSE_URL}?${params}`);
+
+	if (jwt) {
+		url.searchParams.set("__sign", jwt);
+	}
+
+	stream = this.stream(url);
+
+	if (!stream) {
+		console.warn("Cannot connect to SSE endpoint: " + url.toString());
+		return;
+	}
+
+	stream.onmessage = async function (event: MessageEvent) {
+		let _data = JSON.parse(event.data);
+		if (_data.msg === "close_stream") {
+			close_stream(stream_status, that.abort_controller);
+			return;
+		}
+		const event_id = _data.event_id;
+		if (!event_id) {
+			await Promise.all(
+				Object.keys(event_callbacks).map((event_id) =>
+					event_callbacks[event_id](_data)
+				)
+			);
+		} else if (event_callbacks[event_id] && config) {
+			if (
+				_data.msg === "process_completed" &&
+				["sse", "sse_v1", "sse_v2", "sse_v2.1", "sse_v3"].includes(
+					config.protocol
+				)
+			) {
+				unclosed_events.delete(event_id);
+			}
+			let fn: (data: any) => void = event_callbacks[event_id];
+
+			if (typeof window !== "undefined" && typeof document !== "undefined") {
+				// fn(_data); // need to do this to put the event on the end of the event loop, so the browser can refresh between callbacks and not freeze in case of quick generations. See
+				setTimeout(fn, 0, _data); // need to do this to put the event on the end of the event loop, so the browser can refresh between callbacks and not freeze in case of quick generations. See https://github.com/gradio-app/gradio/pull/7055
+			} else {
+				fn(_data);
+			}
+		} else {
+			if (!pending_stream_messages[event_id]) {
+				pending_stream_messages[event_id] = [];
+			}
+			pending_stream_messages[event_id].push(_data);
+		}
+	};
+	stream.onerror = async function (e) {
+		console.error(e);
+		await Promise.all(
+			Object.keys(event_callbacks).map((event_id) =>
+				event_callbacks[event_id]({
+					msg: "broken_connection",
+					message: BROKEN_CONNECTION_MSG
+				})
+			)
+		);
+	};
+}
+
+export function close_stream(
+	stream_status: { open: boolean },
+	abort_controller: AbortController | null
+): void {
+	if (stream_status) {
+		stream_status.open = false;
+		abort_controller?.abort();
+	}
+}
+
+export function apply_diff_stream(
+	pending_diff_streams: Record<string, any[][]>,
+	event_id: string,
+	data: any
+): void {
+	let is_first_generation = !pending_diff_streams[event_id];
+	if (is_first_generation) {
+		pending_diff_streams[event_id] = [];
+		data.data.forEach((value: any, i: number) => {
+			pending_diff_streams[event_id][i] = value;
+		});
+	} else {
+		data.data.forEach((value: any, i: number) => {
+			let new_data = apply_diff(pending_diff_streams[event_id][i], value);
+			pending_diff_streams[event_id][i] = new_data;
+			data.data[i] = new_data;
+		});
+	}
+}
+
+export function apply_diff(
+	obj: any,
+	diff: [string, (number | string)[], any][]
+): any {
+	diff.forEach(([action, path, value]) => {
+		obj = apply_edit(obj, path, action, value);
+	});
+
+	return obj;
+}
+
+function apply_edit(
+	target: any,
+	path: (number | string)[],
+	action: string,
+	value: any
+): any {
+	if (path.length === 0) {
+		if (action === "replace") {
+			return value;
+		} else if (action === "append") {
+			return target + value;
+		}
+		throw new Error(`Unsupported action: ${action}`);
+	}
+
+	let current = target;
+	for (let i = 0; i < path.length - 1; i++) {
+		current = current[path[i]];
+	}
+
+	const last_path = path[path.length - 1];
+	switch (action) {
+		case "replace":
+			current[last_path] = value;
+			break;
+		case "append":
+			current[last_path] += value;
+			break;
+		case "add":
+			if (Array.isArray(current)) {
+				current.splice(Number(last_path), 0, value);
+			} else {
+				current[last_path] = value;
+			}
+			break;
+		case "delete":
+			if (Array.isArray(current)) {
+				current.splice(Number(last_path), 1);
+			} else {
+				delete current[last_path];
+			}
+			break;
+		default:
+			throw new Error(`Unknown action: ${action}`);
+	}
+	return target;
+}
+
+export function readable_stream(
+	input: RequestInfo | URL,
+	init: RequestInit = {}
+): EventSource {
+	const instance: EventSource & { readyState: number } = {
+		close: () => {
+			console.warn("Method not implemented.");
+		},
+		onerror: null,
+		onmessage: null,
+		onopen: null,
+		readyState: 0,
+		url: input.toString(),
+		withCredentials: false,
+		CONNECTING: 0,
+		OPEN: 1,
+		CLOSED: 2,
+		addEventListener: () => {
+			throw new Error("Method not implemented.");
+		},
+		dispatchEvent: () => {
+			throw new Error("Method not implemented.");
+		},
+		removeEventListener: () => {
+			throw new Error("Method not implemented.");
+		}
+	};
+
+	stream(input, init)
+		.then(async (res) => {
+			instance.readyState = instance.OPEN;
+			try {
+				for await (const chunk of res) {
+					//@ts-ignore
+					instance.onmessage && instance.onmessage(chunk);
+				}
+				instance.readyState = instance.CLOSED;
+			} catch (e) {
+				instance.onerror && instance.onerror(e as Event);
+				instance.readyState = instance.CLOSED;
+			}
+		})
+		.catch((e) => {
+			console.error(e);
+			instance.onerror && instance.onerror(e as Event);
+			instance.readyState = instance.CLOSED;
+		});
+
+	return instance as EventSource;
+}

5.49.1/client/src/utils/submit.ts

@@ -0,0 +1,866 @@
+/* eslint-disable complexity */
+import type {
+	Status,
+	Payload,
+	GradioEvent,
+	JsApiData,
+	EndpointInfo,
+	ApiInfo,
+	Config,
+	Dependency,
+	SubmitIterable
+} from "../types";
+
+import { skip_queue, post_message, handle_payload } from "../helpers/data";
+import { resolve_root } from "../helpers/init_helpers";
+import {
+	handle_message,
+	map_data_to_params,
+	process_endpoint
+} from "../helpers/api_info";
+import semiver from "semiver";
+import {
+	BROKEN_CONNECTION_MSG,
+	QUEUE_FULL_MSG,
+	SSE_URL,
+	SSE_DATA_URL,
+	RESET_URL,
+	CANCEL_URL
+} from "../constants";
+import { apply_diff_stream, close_stream } from "./stream";
+import { Client } from "../client";
+
+export function submit(
+	this: Client,
+	endpoint: string | number,
+	data: unknown[] | Record<string, unknown> = {},
+	event_data?: unknown,
+	trigger_id?: number | null,
+	all_events?: boolean
+): SubmitIterable<GradioEvent> {
+	try {
+		const { hf_token } = this.options;
+		const {
+			fetch,
+			app_reference,
+			config,
+			session_hash,
+			api_info,
+			api_map,
+			stream_status,
+			pending_stream_messages,
+			pending_diff_streams,
+			event_callbacks,
+			unclosed_events,
+			post_data,
+			options,
+			api_prefix
+		} = this;
+
+		const that = this;
+
+		if (!api_info) throw new Error("No API found");
+		if (!config) throw new Error("Could not resolve app config");
+
+		let { fn_index, endpoint_info, dependency } = get_endpoint_info(
+			api_info,
+			endpoint,
+			api_map,
+			config
+		);
+
+		let resolved_data = map_data_to_params(data, endpoint_info);
+
+		let websocket: WebSocket;
+		let stream: EventSource | null;
+		let protocol = config.protocol ?? "ws";
+		let event_id_final = "";
+		let event_id_cb: () => string = () => event_id_final;
+
+		const _endpoint = typeof endpoint === "number" ? "/predict" : endpoint;
+		let payload: Payload;
+		let event_id: string | null = null;
+		let complete: Status | undefined | false = false;
+		let last_status: Record<string, Status["stage"]> = {};
+		let url_params =
+			typeof window !== "undefined" && typeof document !== "undefined"
+				? new URLSearchParams(window.location.search).toString()
+				: "";
+
+		const events_to_publish =
+			options?.events?.reduce(
+				(acc, event) => {
+					acc[event] = true;
+					return acc;
+				},
+				{} as Record<string, boolean>
+			) || {};
+
+		// event subscription methods
+		function fire_event(event: GradioEvent): void {
+			if (all_events || events_to_publish[event.type]) {
+				push_event(event);
+			}
+		}
+
+		async function cancel(): Promise<void> {
+			let reset_request = {};
+			let cancel_request = {};
+			if (protocol === "ws") {
+				if (websocket && websocket.readyState === 0) {
+					websocket.addEventListener("open", () => {
+						websocket.close();
+					});
+				} else {
+					websocket.close();
+				}
+				reset_request = { fn_index, session_hash };
+			} else {
+				reset_request = { event_id };
+				cancel_request = { event_id, session_hash, fn_index };
+			}
+
+			try {
+				if (!config) {
+					throw new Error("Could not resolve app config");
+				}
+
+				if ("event_id" in cancel_request) {
+					await fetch(`${config.root}${api_prefix}/${CANCEL_URL}`, {
+						headers: { "Content-Type": "application/json" },
+						method: "POST",
+						body: JSON.stringify(cancel_request)
+					});
+				}
+
+				await fetch(`${config.root}${api_prefix}/${RESET_URL}`, {
+					headers: { "Content-Type": "application/json" },
+					method: "POST",
+					body: JSON.stringify(reset_request)
+				});
+			} catch (e) {
+				console.warn(
+					"The `/reset` endpoint could not be called. Subsequent endpoint results may be unreliable."
+				);
+			}
+		}
+
+		const resolve_heartbeat = async (config: Config): Promise<void> => {
+			await this._resolve_heartbeat(config);
+		};
+
+		async function handle_render_config(render_config: any): Promise<void> {
+			if (!config) return;
+			let render_id: number = render_config.render_id;
+			config.components = [
+				...config.components.filter((c) => c.props.rendered_in !== render_id),
+				...render_config.components
+			];
+			config.dependencies = [
+				...config.dependencies.filter((d) => d.rendered_in !== render_id),
+				...render_config.dependencies
+			];
+			const any_state = config.components.some((c) => c.type === "state");
+			const any_unload = config.dependencies.some((d) =>
+				d.targets.some((t) => t[1] === "unload")
+			);
+			config.connect_heartbeat = any_state || any_unload;
+			await resolve_heartbeat(config);
+			fire_event({
+				type: "render",
+				data: render_config,
+				endpoint: _endpoint,
+				fn_index
+			});
+		}
+
+		this.handle_blob(config.root, resolved_data, endpoint_info).then(
+			async (_payload) => {
+				let input_data = handle_payload(
+					_payload,
+					dependency,
+					config.components,
+					"input",
+					true
+				);
+				payload = {
+					data: input_data || [],
+					event_data,
+					fn_index,
+					trigger_id
+				};
+				if (skip_queue(fn_index, config)) {
+					fire_event({
+						type: "status",
+						endpoint: _endpoint,
+						stage: "pending",
+						queue: false,
+						fn_index,
+						time: new Date()
+					});
+
+					post_data(
+						`${config.root}${api_prefix}/run${
+							_endpoint.startsWith("/") ? _endpoint : `/${_endpoint}`
+						}${url_params ? "?" + url_params : ""}`,
+						{
+							...payload,
+							session_hash
+						}
+					)
+						.then(([output, status_code]: any) => {
+							const data = output.data;
+							if (status_code == 200) {
+								fire_event({
+									type: "data",
+									endpoint: _endpoint,
+									fn_index,
+									data: handle_payload(
+										data,
+										dependency,
+										config.components,
+										"output",
+										options.with_null_state
+									),
+									time: new Date(),
+									event_data,
+									trigger_id
+								});
+								if (output.render_config) {
+									handle_render_config(output.render_config);
+								}
+
+								fire_event({
+									type: "status",
+									endpoint: _endpoint,
+									fn_index,
+									stage: "complete",
+									eta: output.average_duration,
+									queue: false,
+									time: new Date()
+								});
+							} else {
+								fire_event({
+									type: "status",
+									stage: "error",
+									endpoint: _endpoint,
+									fn_index,
+									message: output.error,
+									queue: false,
+									time: new Date()
+								});
+							}
+						})
+						.catch((e) => {
+							fire_event({
+								type: "status",
+								stage: "error",
+								message: e.message,
+								endpoint: _endpoint,
+								fn_index,
+								queue: false,
+								time: new Date()
+							});
+						});
+				} else if (protocol == "ws") {
+					const { ws_protocol, host } = await process_endpoint(
+						app_reference,
+						hf_token
+					);
+
+					fire_event({
+						type: "status",
+						stage: "pending",
+						queue: true,
+						endpoint: _endpoint,
+						fn_index,
+						time: new Date()
+					});
+
+					let url = new URL(
+						`${ws_protocol}://${resolve_root(
+							host,
+							config.root as string,
+							true
+						)}/queue/join${url_params ? "?" + url_params : ""}`
+					);
+
+					if (this.jwt) {
+						url.searchParams.set("__sign", this.jwt);
+					}
+
+					websocket = new WebSocket(url);
+
+					websocket.onclose = (evt) => {
+						if (!evt.wasClean) {
+							fire_event({
+								type: "status",
+								stage: "error",
+								broken: true,
+								message: BROKEN_CONNECTION_MSG,
+								queue: true,
+								endpoint: _endpoint,
+								fn_index,
+								time: new Date()
+							});
+						}
+					};
+
+					websocket.onmessage = function (event) {
+						const _data = JSON.parse(event.data);
+						const { type, status, data } = handle_message(
+							_data,
+							last_status[fn_index]
+						);
+
+						if (type === "update" && status && !complete) {
+							// call 'status' listeners
+							fire_event({
+								type: "status",
+								endpoint: _endpoint,
+								fn_index,
+								time: new Date(),
+								...status
+							});
+							if (status.stage === "error") {
+								websocket.close();
+							}
+						} else if (type === "hash") {
+							websocket.send(JSON.stringify({ fn_index, session_hash }));
+							return;
+						} else if (type === "data") {
+							websocket.send(JSON.stringify({ ...payload, session_hash }));
+						} else if (type === "complete") {
+							complete = status;
+						} else if (type === "log") {
+							fire_event({
+								type: "log",
+								title: data.title,
+								log: data.log,
+								level: data.level,
+								endpoint: _endpoint,
+								duration: data.duration,
+								visible: data.visible,
+								fn_index
+							});
+						} else if (type === "generating") {
+							fire_event({
+								type: "status",
+								time: new Date(),
+								...status,
+								stage: status?.stage!,
+								queue: true,
+								endpoint: _endpoint,
+								fn_index
+							});
+						}
+						if (data) {
+							fire_event({
+								type: "data",
+								time: new Date(),
+								data: handle_payload(
+									data.data,
+									dependency,
+									config.components,
+									"output",
+									options.with_null_state
+								),
+								endpoint: _endpoint,
+								fn_index,
+								event_data,
+								trigger_id
+							});
+
+							if (complete) {
+								fire_event({
+									type: "status",
+									time: new Date(),
+									...complete,
+									stage: status?.stage!,
+									queue: true,
+									endpoint: _endpoint,
+									fn_index
+								});
+								websocket.close();
+							}
+						}
+					};
+
+					// different ws contract for gradio versions older than 3.6.0
+					//@ts-ignore
+					if (semiver(config.version || "2.0.0", "3.6") < 0) {
+						addEventListener("open", () =>
+							websocket.send(JSON.stringify({ hash: session_hash }))
+						);
+					}
+				} else if (protocol == "sse") {
+					fire_event({
+						type: "status",
+						stage: "pending",
+						queue: true,
+						endpoint: _endpoint,
+						fn_index,
+						time: new Date()
+					});
+					var params = new URLSearchParams({
+						fn_index: fn_index.toString(),
+						session_hash: session_hash
+					}).toString();
+					let url = new URL(
+						`${config.root}${api_prefix}/${SSE_URL}?${
+							url_params ? url_params + "&" : ""
+						}${params}`
+					);
+
+					if (this.jwt) {
+						url.searchParams.set("__sign", this.jwt);
+					}
+
+					stream = this.stream(url);
+
+					if (!stream) {
+						return Promise.reject(
+							new Error("Cannot connect to SSE endpoint: " + url.toString())
+						);
+					}
+
+					stream.onmessage = async function (event: MessageEvent) {
+						const _data = JSON.parse(event.data);
+						const { type, status, data } = handle_message(
+							_data,
+							last_status[fn_index]
+						);
+
+						if (type === "update" && status && !complete) {
+							// call 'status' listeners
+							fire_event({
+								type: "status",
+								endpoint: _endpoint,
+								fn_index,
+								time: new Date(),
+								...status
+							});
+							if (status.stage === "error") {
+								stream?.close();
+								close();
+							}
+						} else if (type === "data") {
+							let [_, status] = await post_data(
+								`${config.root}${api_prefix}/queue/data`,
+								{
+									...payload,
+									session_hash,
+									event_id
+								}
+							);
+							if (status !== 200) {
+								fire_event({
+									type: "status",
+									stage: "error",
+									message: BROKEN_CONNECTION_MSG,
+									queue: true,
+									endpoint: _endpoint,
+									fn_index,
+									time: new Date()
+								});
+								stream?.close();
+								close();
+							}
+						} else if (type === "complete") {
+							complete = status;
+						} else if (type === "log") {
+							fire_event({
+								type: "log",
+								title: data.title,
+								log: data.log,
+								level: data.level,
+								endpoint: _endpoint,
+								duration: data.duration,
+								visible: data.visible,
+								fn_index
+							});
+						} else if (type === "generating" || type === "streaming") {
+							fire_event({
+								type: "status",
+								time: new Date(),
+								...status,
+								stage: status?.stage!,
+								queue: true,
+								endpoint: _endpoint,
+								fn_index
+							});
+						}
+						if (data) {
+							fire_event({
+								type: "data",
+								time: new Date(),
+								data: handle_payload(
+									data.data,
+									dependency,
+									config.components,
+									"output",
+									options.with_null_state
+								),
+								endpoint: _endpoint,
+								fn_index,
+								event_data,
+								trigger_id
+							});
+
+							if (complete) {
+								fire_event({
+									type: "status",
+									time: new Date(),
+									...complete,
+									stage: status?.stage!,
+									queue: true,
+									endpoint: _endpoint,
+									fn_index
+								});
+								stream?.close();
+								close();
+							}
+						}
+					};
+				} else if (
+					protocol == "sse_v1" ||
+					protocol == "sse_v2" ||
+					protocol == "sse_v2.1" ||
+					protocol == "sse_v3"
+				) {
+					// latest API format. v2 introduces sending diffs for intermediate outputs in generative functions, which makes payloads lighter.
+					// v3 only closes the stream when the backend sends the close stream message.
+					fire_event({
+						type: "status",
+						stage: "pending",
+						queue: true,
+						endpoint: _endpoint,
+						fn_index,
+						time: new Date()
+					});
+					let hostname = "";
+					if (
+						typeof window !== "undefined" &&
+						typeof document !== "undefined"
+					) {
+						hostname = window?.location?.hostname;
+					}
+
+					let hfhubdev = "dev.spaces.huggingface.tech";
+					const origin = hostname.includes(".dev.")
+						? `https://moon-${hostname.split(".")[1]}.${hfhubdev}`
+						: `https://huggingface.co`;
+
+					const is_zerogpu_iframe =
+						typeof window !== "undefined" &&
+						typeof document !== "undefined" &&
+						window.parent != window &&
+						window.supports_zerogpu_headers;
+					const zerogpu_auth_promise = is_zerogpu_iframe
+						? post_message<Map<string, string>>("zerogpu-headers", origin)
+						: Promise.resolve(null);
+					const post_data_promise = zerogpu_auth_promise.then((headers) => {
+						return post_data(
+							`${config.root}${api_prefix}/${SSE_DATA_URL}?${url_params}`,
+							{
+								...payload,
+								session_hash
+							},
+							headers
+						);
+					});
+					post_data_promise.then(async ([response, status]: any) => {
+						if (status === 503) {
+							fire_event({
+								type: "status",
+								stage: "error",
+								message: QUEUE_FULL_MSG,
+								queue: true,
+								endpoint: _endpoint,
+								fn_index,
+								time: new Date()
+							});
+						} else if (status === 422) {
+							fire_event({
+								type: "status",
+								stage: "error",
+								message: response.detail,
+								queue: true,
+								endpoint: _endpoint,
+								fn_index,
+								code: "validation_error",
+								time: new Date()
+							});
+							close();
+						} else if (status !== 200) {
+							fire_event({
+								type: "status",
+								stage: "error",
+								broken: false,
+								message: response.detail,
+								queue: true,
+								endpoint: _endpoint,
+								fn_index,
+								time: new Date()
+							});
+						} else {
+							event_id = response.event_id as string;
+							event_id_final = event_id;
+							let callback = async function (_data: object): Promise<void> {
+								try {
+									const { type, status, data, original_msg } = handle_message(
+										_data,
+										last_status[fn_index]
+									);
+
+									if (type == "heartbeat") {
+										return;
+									}
+
+									if (type === "update" && status && !complete) {
+										// call 'status' listeners
+										fire_event({
+											type: "status",
+											endpoint: _endpoint,
+											fn_index,
+											time: new Date(),
+											original_msg: original_msg,
+											...status
+										});
+									} else if (type === "complete") {
+										complete = status;
+									} else if (
+										type == "unexpected_error" ||
+										type == "broken_connection"
+									) {
+										console.error("Unexpected error", status?.message);
+										const broken = type === "broken_connection";
+										fire_event({
+											type: "status",
+											stage: "error",
+											message:
+												status?.message || "An Unexpected Error Occurred!",
+											queue: true,
+											endpoint: _endpoint,
+											broken,
+											session_not_found: status?.session_not_found,
+											fn_index,
+											time: new Date()
+										});
+									} else if (type === "log") {
+										fire_event({
+											type: "log",
+											title: data.title,
+											log: data.log,
+											level: data.level,
+											endpoint: _endpoint,
+											duration: data.duration,
+											visible: data.visible,
+											fn_index
+										});
+										return;
+									} else if (type === "generating" || type === "streaming") {
+										fire_event({
+											type: "status",
+											time: new Date(),
+											...status,
+											stage: status?.stage!,
+											queue: true,
+											endpoint: _endpoint,
+											fn_index
+										});
+										if (
+											data &&
+											dependency.connection !== "stream" &&
+											["sse_v2", "sse_v2.1", "sse_v3"].includes(protocol)
+										) {
+											apply_diff_stream(pending_diff_streams, event_id!, data);
+										}
+									}
+									if (data) {
+										fire_event({
+											type: "data",
+											time: new Date(),
+											data: handle_payload(
+												data.data,
+												dependency,
+												config.components,
+												"output",
+												options.with_null_state
+											),
+											endpoint: _endpoint,
+											fn_index
+										});
+										if (data.render_config) {
+											await handle_render_config(data.render_config);
+										}
+
+										if (complete) {
+											fire_event({
+												type: "status",
+												time: new Date(),
+												...complete,
+												stage: status?.stage!,
+												queue: true,
+												endpoint: _endpoint,
+												fn_index
+											});
+											close();
+										}
+									}
+
+									if (
+										status?.stage === "complete" ||
+										status?.stage === "error"
+									) {
+										if (event_callbacks[event_id!]) {
+											delete event_callbacks[event_id!];
+										}
+										if (event_id! in pending_diff_streams) {
+											delete pending_diff_streams[event_id!];
+										}
+									}
+								} catch (e) {
+									console.error("Unexpected client exception", e);
+									fire_event({
+										type: "status",
+										stage: "error",
+										message: "An Unexpected Error Occurred!",
+										queue: true,
+										endpoint: _endpoint,
+										fn_index,
+										time: new Date()
+									});
+									if (["sse_v2", "sse_v2.1", "sse_v3"].includes(protocol)) {
+										close_stream(stream_status, that.abort_controller);
+										stream_status.open = false;
+										close();
+									}
+								}
+							};
+
+							if (event_id in pending_stream_messages) {
+								pending_stream_messages[event_id].forEach((msg) =>
+									callback(msg)
+								);
+								delete pending_stream_messages[event_id];
+							}
+							// @ts-ignore
+							event_callbacks[event_id] = callback;
+							unclosed_events.add(event_id);
+							if (!stream_status.open) {
+								await this.open_stream();
+							}
+						}
+					});
+				}
+			}
+		);
+
+		let done = false;
+		const values: (IteratorResult<GradioEvent> | PromiseLike<never>)[] = [];
+		const resolvers: ((
+			value: IteratorResult<GradioEvent> | PromiseLike<never>
+		) => void)[] = [];
+
+		function close(): void {
+			done = true;
+			while (resolvers.length > 0)
+				(resolvers.shift() as (typeof resolvers)[0])({
+					value: undefined,
+					done: true
+				});
+		}
+
+		function push(
+			data: { value: GradioEvent; done: boolean } | PromiseLike<never>
+		): void {
+			if (resolvers.length > 0) {
+				(resolvers.shift() as (typeof resolvers)[0])(data);
+			} else {
+				values.push(data);
+			}
+		}
+
+		function push_error(error: unknown): void {
+			push(thenable_reject(error));
+			close();
+		}
+
+		function push_event(event: GradioEvent): void {
+			push({ value: event, done: false });
+		}
+
+		function next(): Promise<IteratorResult<GradioEvent, unknown>> {
+			if (values.length > 0) {
+				return Promise.resolve(values.shift() as (typeof values)[0]);
+			}
+			return new Promise((resolve) => resolvers.push(resolve));
+		}
+
+		const iterator = {
+			[Symbol.asyncIterator]: () => iterator,
+			next,
+			throw: async (value: unknown) => {
+				push_error(value);
+				return next();
+			},
+			return: async () => {
+				close();
+				return next();
+			},
+			cancel,
+			event_id: event_id_cb
+		};
+
+		return iterator;
+	} catch (error) {
+		console.error("Submit function encountered an error:", error);
+		throw error;
+	}
+}
+
+function thenable_reject<T>(error: T): PromiseLike<never> {
+	return {
+		then: (
+			resolve: (value: never) => PromiseLike<never>,
+			reject: (error: T) => PromiseLike<never>
+		) => reject(error)
+	};
+}
+
+function get_endpoint_info(
+	api_info: ApiInfo<JsApiData>,
+	endpoint: string | number,
+	api_map: Record<string, number>,
+	config: Config
+): {
+	fn_index: number;
+	endpoint_info: EndpointInfo<JsApiData>;
+	dependency: Dependency;
+} {
+	let fn_index: number;
+	let endpoint_info: EndpointInfo<JsApiData>;
+	let dependency: Dependency;
+
+	if (typeof endpoint === "number") {
+		fn_index = endpoint;
+		endpoint_info = api_info.unnamed_endpoints[fn_index];
+		dependency = config.dependencies.find((dep) => dep.id == endpoint)!;
+	} else {
+		const trimmed_endpoint = endpoint.replace(/^\//, "");
+
+		fn_index = api_map[trimmed_endpoint];
+		endpoint_info = api_info.named_endpoints[endpoint.trim()];
+		dependency = config.dependencies.find(
+			(dep) => dep.id == api_map[trimmed_endpoint]
+		)!;
+	}
+
+	if (typeof fn_index !== "number") {
+		throw new Error(
+			"There is no endpoint matching that name of fn_index matching that number."
+		);
+	}
+	return { fn_index, endpoint_info, dependency };
+}

5.49.1/client/src/utils/upload_files.ts

@@ -0,0 +1,52 @@
+import type { Client } from "..";
+import { BROKEN_CONNECTION_MSG, UPLOAD_URL } from "../constants";
+import type { UploadResponse } from "../types";
+
+export async function upload_files(
+	this: Client,
+	root_url: string,
+	files: (Blob | File)[],
+	upload_id?: string
+): Promise<UploadResponse> {
+	const headers: {
+		Authorization?: string;
+	} = {};
+	if (this?.options?.hf_token) {
+		headers.Authorization = `Bearer ${this.options.hf_token}`;
+	}
+
+	const chunkSize = 1000;
+	const uploadResponses = [];
+	let response: Response;
+
+	for (let i = 0; i < files.length; i += chunkSize) {
+		const chunk = files.slice(i, i + chunkSize);
+		const formData = new FormData();
+		chunk.forEach((file) => {
+			formData.append("files", file);
+		});
+		try {
+			const upload_url = upload_id
+				? `${root_url}${this.api_prefix}/${UPLOAD_URL}?upload_id=${upload_id}`
+				: `${root_url}${this.api_prefix}/${UPLOAD_URL}`;
+
+			response = await this.fetch(upload_url, {
+				method: "POST",
+				body: formData,
+				headers,
+				credentials: "include"
+			});
+		} catch (e) {
+			throw new Error(BROKEN_CONNECTION_MSG + (e as Error).message);
+		}
+		if (!response.ok) {
+			const error_text = await response.text();
+			return { error: `HTTP ${response.status}: ${error_text}` };
+		}
+		const output: UploadResponse["files"] = await response.json();
+		if (output) {
+			uploadResponses.push(...output);
+		}
+	}
+	return { files: uploadResponses };
+}

5.49.1/client/src/utils/view_api.ts

@@ -0,0 +1,71 @@
+import type { ApiInfo, ApiData } from "../types";
+import semiver from "semiver";
+import { API_INFO_URL, BROKEN_CONNECTION_MSG } from "../constants";
+import { Client } from "../client";
+import { SPACE_FETCHER_URL } from "../constants";
+import { join_urls, transform_api_info } from "../helpers/api_info";
+
+export async function view_api(this: Client): Promise<any> {
+	if (this.api_info) return this.api_info;
+
+	const { hf_token } = this.options;
+	const { config } = this;
+
+	const headers: {
+		Authorization?: string;
+		"Content-Type": "application/json";
+	} = { "Content-Type": "application/json" };
+
+	if (hf_token) {
+		headers.Authorization = `Bearer ${hf_token}`;
+	}
+
+	if (!config) {
+		return;
+	}
+
+	try {
+		let response: Response;
+		let api_info: ApiInfo<ApiData> | { api: ApiInfo<ApiData> };
+		if (typeof window !== "undefined" && window.gradio_api_info) {
+			api_info = window.gradio_api_info;
+		} else {
+			if (semiver(config?.version || "2.0.0", "3.30") < 0) {
+				response = await this.fetch(SPACE_FETCHER_URL, {
+					method: "POST",
+					body: JSON.stringify({
+						serialize: false,
+						config: JSON.stringify(config)
+					}),
+					headers,
+					credentials: "include"
+				});
+			} else {
+				const url = join_urls(config.root, this.api_prefix, API_INFO_URL);
+				response = await this.fetch(url, {
+					headers,
+					credentials: "include"
+				});
+			}
+
+			if (!response.ok) {
+				throw new Error(BROKEN_CONNECTION_MSG);
+			}
+			api_info = await response.json();
+		}
+		if ("api" in api_info) {
+			api_info = api_info.api;
+		}
+
+		if (
+			api_info.named_endpoints["/predict"] &&
+			!api_info.unnamed_endpoints["0"]
+		) {
+			api_info.unnamed_endpoints[0] = api_info.named_endpoints["/predict"];
+		}
+
+		return transform_api_info(api_info, config, this.api_map);
+	} catch (e) {
+		throw new Error("Could not get API info. " + (e as Error).message);
+	}
+}

5.49.1/client/src/vite-env.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="vite/client" />
+
+declare const BROWSER_BUILD: boolean;

5.49.1/client/tsconfig.json

@@ -0,0 +1,27 @@
+{
+	"include": ["src/**/*"],
+	"exclude": ["src/**/*.test.ts", "src/**/*.node-test.ts"],
+	"compilerOptions": {
+		"allowJs": true,
+		"declaration": true,
+		"emitDeclarationOnly": true,
+		"outDir": "dist",
+		"declarationMap": true,
+		"module": "ESNext",
+		"target": "ES2020",
+		"useDefineForClassFields": true,
+		"lib": ["ES2020", "DOM", "DOM.Iterable"],
+		"skipLibCheck": true,
+
+		/* Bundler */
+		"moduleResolution": "Bundler",
+		"skipDefaultLibCheck": true,
+		"allowImportingTsExtensions": true,
+		"esModuleInterop": true,
+		"resolveJsonModule": true,
+		"isolatedModules": true,
+
+		/* Linting */
+		"strict": true
+	}
+}