@gradio/client 0.16.0 → 0.18.0

package/src/types.ts

@@ -1,13 +1,131 @@
+// API Data Types
+
+import { hardware_types } from "./helpers/spaces";
+
+export interface ApiData {
+	label: string;
+	type: {
+		type: any;
+		description: string;
+	};
+	component: string;
+	example_input?: any;
+	python_type: { type: string; description: string };
+	serializer: string;
+}
+
+export interface JsApiData {
+	label: string;
+	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[];
+
+// Event and Submission Types
+
+type event = <K extends EventType>(
+	eventType: K,
+	listener: EventListener<K>
+) => SubmitReturn;
+
+type predict = (
+	endpoint: string | number,
+	data?: unknown[],
+	event_data?: unknown
+) => Promise<unknown>;
+
+export type client_return = {
+	config: Config | undefined;
+	predict: predict;
+	submit: (
+		endpoint: string | number,
+		data: unknown[],
+		event_data?: unknown,
+		trigger_id?: number | null
+	) => SubmitReturn;
+	component_server: (
+		component_id: number,
+		fn_name: string,
+		data: unknown[]
+	) => any;
+	view_api: (_fetch: typeof fetch) => Promise<ApiInfo<JsApiData>>;
+};
+
+export type SubmitReturn = {
+	on: event;
+	off: event;
+	cancel: () => Promise<void>;
+	destroy: () => void;
+};
+
+// Space Status Types
+
+export type SpaceStatus = SpaceStatusNormal | SpaceStatusError;
+
+export interface SpaceStatusNormal {
+	status: "sleeping" | "running" | "building" | "error" | "stopped";
+	detail:
+		| "SLEEPING"
+		| "RUNNING"
+		| "RUNNING_BUILDING"
+		| "BUILDING"
+		| "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 {
-	auth_required: boolean | undefined;
+	auth_required: boolean;
+	analytics_enabled: boolean;
+	connect_heartbeat: boolean;
 	auth_message: string;
 	components: any[];
 	css: string | null;
 	js: string | null;
 	head: string | null;
-	dependencies: any[];
+	dependencies: Dependency[];
 	dev_mode: boolean;
 	enable_queue: boolean;
+	show_error: boolean;
 	layout: any;
 	mode: "blocks" | "interface";
 	root: string;
@@ -16,81 +134,91 @@ export interface Config {
 	title: string;
 	version: string;
 	space_id: string | null;
+	is_space: boolean;
 	is_colab: boolean;
 	show_api: boolean;
 	stylesheets: string[];
 	path: string;
-	protocol?: "sse_v2.1" | "sse_v2" | "sse_v1" | "sse" | "ws";
+	protocol: "sse_v3" | "sse_v2.1" | "sse_v2" | "sse_v1" | "sse" | "ws";
+	max_file_size?: number;
+}
+
+export interface Dependency {
+	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";
+	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_mode: "once" | "multiple" | "always_last";
+	final_event: Payload | null;
+	show_api: boolean;
+	zerogpu?: boolean;
+}
+
+export interface DependencyTypes {
+	continuous: boolean;
+	generator: boolean;
 }
 
 export interface Payload {
+	fn_index: number;
 	data: unknown[];
-	fn_index?: number;
-	event_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[];
 }
 
-export interface Status {
-	queue: boolean;
-	code?: string;
-	success?: boolean;
-	stage: "pending" | "error" | "complete" | "generating";
-	broken?: boolean;
-	size?: number;
-	position?: number;
-	eta?: number;
-	message?: string;
-	progress_data?: {
-		progress: number | null;
-		index: number | null;
-		length: number | null;
-		unit: string | null;
-		desc: string | null;
-	}[];
-	time?: Date;
-}
+// Client and File Handling Types
 
-export interface LogMessage {
-	log: string;
-	level: "warning" | "info";
+export interface DuplicateOptions extends ClientOptions {
+	private?: boolean;
+	hardware?: (typeof hardware_types)[number];
+	timeout?: number;
 }
 
-export interface SpaceStatusNormal {
-	status: "sleeping" | "running" | "building" | "error" | "stopped";
-	detail:
-		| "SLEEPING"
-		| "RUNNING"
-		| "RUNNING_BUILDING"
-		| "BUILDING"
-		| "NOT_FOUND";
-	load_status: "pending" | "error" | "complete" | "generating";
-	message: string;
+export interface ClientOptions {
+	hf_token?: `hf_${string}`;
+	status_callback?: SpaceStatusCallback | null;
 }
-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 interface FileData {
+	name: string;
+	orig_name?: string;
+	size?: number;
+	data: string;
+	blob?: File;
+	is_file?: boolean;
+	mime_type?: string;
+	alt_text?: string;
 }
-export type SpaceStatus = SpaceStatusNormal | SpaceStatusError;
 
-export type status_callback_function = (a: Status) => void;
-export type SpaceStatusCallback = (a: SpaceStatus) => void;
+// Event and Listener Types
 
 export type EventType = "data" | "status" | "log";
 
@@ -107,13 +235,27 @@ export type EventListener<K extends EventType> = (event: Event<K>) => void;
 export type ListenerMap<K extends EventType> = {
 	[P in K]?: EventListener<K>[];
 };
-export interface FileData {
-	name: string;
-	orig_name?: string;
+export interface LogMessage {
+	log: string;
+	level: "warning" | "info";
+}
+
+export interface Status {
+	queue: boolean;
+	code?: string;
+	success?: boolean;
+	stage: "pending" | "error" | "complete" | "generating";
+	broken?: boolean;
 	size?: number;
-	data: string;
-	blob?: File;
-	is_file?: boolean;
-	mime_type?: string;
-	alt_text?: string;
+	position?: number;
+	eta?: number;
+	message?: string;
+	progress_data?: {
+		progress: number | null;
+		index: number | null;
+		length: number | null;
+		unit: string | null;
+		desc: string | null;
+	}[];
+	time?: Date;
 }

package/src/upload.ts

@@ -1,26 +1,30 @@
-import { upload_files } from "./client";
-
-function is_url(str: string): boolean {
-	try {
-		const url = new URL(str);
-		return url.protocol === "http:" || url.protocol === "https:";
-	} catch {
-		return false;
-	}
-}
+import type { UploadResponse } from "./types";
+import type { Client } from "./client";
 
 export async function upload(
+	this: Client,
 	file_data: FileData[],
-	root: string,
+	root_url: string,
 	upload_id?: string,
-	upload_fn: typeof upload_files = upload_files
+	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 upload_fn(root, files, undefined, upload_id).then(
+		await this.upload_files(root_url, files, upload_id).then(
 			async (response: { files?: string[]; error?: string }) => {
 				if (response.error) {
 					throw new Error(response.error);
@@ -30,7 +34,7 @@ export async function upload(
 							const file = new FileData({
 								...file_data[i],
 								path: f,
-								url: root + "/file=" + f
+								url: root_url + "/file=" + f
 							});
 							return file;
 						});
@@ -48,7 +52,7 @@ export async function prepare_files(
 	is_stream?: boolean
 ): Promise<FileData[]> {
 	return files.map(
-		(f, i) =>
+		(f) =>
 			new FileData({
 				path: f.name,
 				orig_name: f.name,

package/src/utils/duplicate.ts

@@ -0,0 +1,104 @@
+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";
+
+export async function duplicate(
+	app_reference: string,
+	options: DuplicateOptions
+): Promise<Client> {
+	const { hf_token, private: _private, hardware, timeout } = options;
+
+	if (hardware && !hardware_types.includes(hardware)) {
+		throw new Error(
+			`Invalid hardware type provided. Valid types are: ${hardware_types
+				.map((v) => `"${v}"`)
+				.join(",")}.`
+		);
+	}
+	const headers = {
+		Authorization: `Bearer ${hf_token}`,
+		"Content-Type": "application/json"
+	};
+
+	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];
+	}
+}

package/src/utils/handle_blob.ts

@@ -0,0 +1,47 @@
+import { update_object, walk_and_store_blobs } from "../helpers/data";
+import type { ApiData, EndpointInfo, JsApiData } from "../types";
+import { FileData } from "../upload";
+import type { Client } from "..";
+
+export async function handle_blob(
+	this: Client,
+	endpoint: string,
+	data: unknown[],
+	api_info: EndpointInfo<JsApiData | ApiData>
+): Promise<unknown[]> {
+	const self = this;
+
+	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: 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;
+}

package/src/utils/post_data.ts

@@ -0,0 +1,37 @@
+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 }
+		});
+	} 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];
+}

package/src/utils/predict.ts

@@ -0,0 +1,56 @@
+import { Client } from "../client";
+import type { Dependency, SubmitReturn } from "../types";
+
+export async function predict(
+	this: Client,
+	endpoint: string | number,
+	data?: unknown[]
+): Promise<SubmitReturn> {
+	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[endpoint];
+	} else {
+		const trimmed_endpoint = endpoint.replace(/^\//, "");
+		dependency = this.config.dependencies[this.api_map[trimmed_endpoint]];
+	}
+
+	if (dependency?.types.continuous) {
+		throw new Error(
+			"Cannot call predict on this function as it may run forever. Use submit instead"
+		);
+	}
+
+	return new Promise(async (resolve, reject) => {
+		const app = this.submit(endpoint, data || []);
+		let result: unknown;
+
+		app
+			.on("data", (d: unknown) => {
+				// if complete message comes before data, resolve here
+				if (status_complete) {
+					app.destroy();
+					resolve(d as SubmitReturn);
+				}
+				data_returned = true;
+				result = d;
+			})
+			.on("status", (status) => {
+				if (status.stage === "error") reject(status);
+				if (status.stage === "complete") {
+					status_complete = true;
+					// if complete message comes after data, resolve here
+					if (data_returned) {
+						app.destroy();
+						resolve(result as SubmitReturn);
+					}
+				}
+			});
+	});
+}