@gradio/client 0.15.1 → 0.17.0

package/src/utils/duplicate.ts

@@ -0,0 +1,87 @@
+import {
+	get_space_hardware,
+	hardware_types,
+	set_space_timeout
+} from "../helpers/spaces";
+import type { DuplicateOptions } from "../types";
+import { Client } from "../client";
+
+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;
+
+	if (!hardware) {
+		original_hardware = await get_space_hardware(app_reference, hf_token);
+	}
+
+	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(duplicated_space.url, options);
+	} catch (e: any) {
+		throw new Error(e);
+	}
+}

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?.name
+			};
+		})
+	);
+
+	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_implementation(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);
+					}
+				}
+			});
+	});
+}

package/src/utils/stream.ts

@@ -0,0 +1,166 @@
+import { BROKEN_CONNECTION_MSG } from "../constants";
+import type { Client } from "../client";
+
+export function open_stream(this: Client): void {
+	let {
+		event_callbacks,
+		unclosed_events,
+		pending_stream_messages,
+		stream_status,
+		config
+	} = this;
+
+	if (!config) {
+		throw new Error("Could not resolve app config");
+	}
+
+	stream_status.open = true;
+
+	let event_source: EventSource | null = null;
+	let params = new URLSearchParams({
+		session_hash: this.session_hash
+	}).toString();
+
+	let url = new URL(`${config.root}/queue/data?${params}`);
+	event_source = this.eventSource_factory(url);
+
+	if (!event_source) {
+		throw new Error("Cannot connect to sse endpoint: " + url.toString());
+	}
+
+	event_source.onmessage = async function (event) {
+		let _data = JSON.parse(event.data);
+		if (_data.msg === "close_stream") {
+			close_stream(stream_status, event_source);
+			return;
+		}
+		const event_id = _data.event_id;
+		if (!event_id) {
+			await Promise.all(
+				Object.keys(event_callbacks).map(
+					(event_id) =>
+						// @ts-ignore
+						event_callbacks[event_id](_data) // todo: check event_callbacks
+				)
+			);
+		} else if (event_callbacks[event_id] && config) {
+			if (
+				_data.msg === "process_completed" &&
+				["sse", "sse_v1", "sse_v2", "sse_v2.1"].includes(config.protocol)
+			) {
+				unclosed_events.delete(event_id);
+				if (unclosed_events.size === 0) {
+					close_stream(stream_status, event_source);
+				}
+			}
+			let fn = event_callbacks[event_id];
+			window.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 {
+			if (!pending_stream_messages[event_id]) {
+				pending_stream_messages[event_id] = [];
+			}
+			pending_stream_messages[event_id].push(_data);
+		}
+	};
+	event_source.onerror = async function () {
+		await Promise.all(
+			Object.keys(event_callbacks).map((event_id) =>
+				// @ts-ignore
+				event_callbacks[event_id]({
+					msg: "unexpected_error",
+					message: BROKEN_CONNECTION_MSG
+				})
+			)
+		);
+		close_stream(stream_status, event_source);
+	};
+}
+
+export function close_stream(
+	stream_status: { open: boolean },
+	event_source: EventSource | null
+): void {
+	if (stream_status && event_source) {
+		stream_status.open = false;
+		event_source?.close();
+	}
+}
+
+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;
+}