@gradio/client 2.4.0 → 2.5.1

package/dist/index.js

@@ -1428,6 +1428,307 @@ function readable_stream(input, init = {}) {
 	return instance;
 }
 //#endregion
+//#region src/utils/run_history.ts
+var KEY_ROOT = "gradio:run-history:";
+var STORAGE_PREFIX = `${KEY_ROOT}v2:`;
+var REPLAY_PREFIX = `${KEY_ROOT}replay:v2:`;
+var MAX_RUNS = 100;
+var MAX_APPS = 8;
+/**
+* Run history is a side effect of submitting, never the point of it, so no
+* failure in here may propagate into the caller and break the app. Every
+* exported function routes through this.
+*/
+function safely(operation, fallback) {
+	try {
+		return operation();
+	} catch (error) {
+		console.warn("Could not update the run history.", error);
+		return fallback;
+	}
+}
+/**
+* The URL of the run history page for an app. `root` never carries a trailing
+* slash, so it cannot simply be concatenated with the path.
+*/
+function run_history_url(root, api_prefix = "/gradio_api") {
+	return `${root.replace(/\/+$/, "")}${api_prefix}/runs`;
+}
+function storage_key(scope) {
+	if (typeof window === "undefined") return null;
+	const app_id = scope?.app_id;
+	if (app_id === null || app_id === void 0 || app_id === "") return null;
+	try {
+		if (!window.localStorage) return null;
+		return `${STORAGE_PREFIX}${app_id}${scope?.username ? `:user:${encodeURIComponent(scope.username)}` : ""}`;
+	} catch {
+		return null;
+	}
+}
+function replay_key(scope) {
+	const key = storage_key(scope);
+	return key ? key.replace(STORAGE_PREFIX, REPLAY_PREFIX) : null;
+}
+/** When a run was most recently saved under a key, for deciding what to drop. */
+function last_saved_at(key) {
+	try {
+		const runs = JSON.parse(window.localStorage.getItem(key) || "[]");
+		return Array.isArray(runs) && runs.length ? Date.parse(runs[0]?.started_at) || 0 : 0;
+	} catch {
+		return 0;
+	}
+}
+/**
+* Drops the histories of long-gone app instances. Every restart mints a new app
+* id, so without this the browser would keep every history an app ever had and
+* eventually run out of room for the current one.
+*/
+function prune_apps(current_key) {
+	const keys = Object.keys(window.localStorage).filter((key) => key.startsWith(KEY_ROOT));
+	const stale = [...keys.filter((key) => !key.startsWith(STORAGE_PREFIX) && !key.startsWith(REPLAY_PREFIX)), ...keys.filter((key) => key.startsWith(STORAGE_PREFIX) && key !== current_key).sort((a, b) => last_saved_at(b) - last_saved_at(a)).slice(MAX_APPS - 1)];
+	for (const key of stale) try {
+		window.localStorage.removeItem(key);
+		window.sessionStorage.removeItem(key.replace(STORAGE_PREFIX, REPLAY_PREFIX));
+	} catch {}
+}
+function make_id() {
+	if (typeof crypto !== "undefined" && crypto.randomUUID) return crypto.randomUUID();
+	return `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+function clone_for_storage(value) {
+	const seen = /* @__PURE__ */ new WeakSet();
+	try {
+		return JSON.parse(JSON.stringify(value, (_key, item) => {
+			if (typeof item === "bigint") return item.toString();
+			if (typeof item === "object" && item !== null) {
+				if (seen.has(item)) return "[Circular]";
+				seen.add(item);
+			}
+			return item;
+		}));
+	} catch {
+		return "[Unserializable value]";
+	}
+}
+function read_run_history_impl(scope) {
+	const key = storage_key(scope);
+	if (!key) return [];
+	try {
+		const value = JSON.parse(window.localStorage.getItem(key) || "[]");
+		return Array.isArray(value) ? value : [];
+	} catch {
+		return [];
+	}
+}
+function write_run_history(scope, runs) {
+	const key = storage_key(scope);
+	if (!key) return;
+	let next = runs.slice(0, MAX_RUNS);
+	let pruned = false;
+	while (next.length > 0) try {
+		window.localStorage.setItem(key, JSON.stringify(next));
+		return;
+	} catch {
+		if (!pruned) {
+			pruned = true;
+			prune_apps(key);
+			continue;
+		}
+		next = next.slice(0, -1);
+	}
+	try {
+		window.localStorage.removeItem(key);
+	} catch {}
+}
+function clear_run_history_impl(scope) {
+	const key = storage_key(scope);
+	if (!key) return;
+	try {
+		window.localStorage.removeItem(key);
+	} catch {}
+	notify_run_history_change();
+}
+function delete_run_history_impl(scope, id) {
+	write_run_history(scope, read_run_history_impl(scope).filter((run) => run.id !== id));
+	notify_run_history_change();
+}
+var CHANGE_EVENT = "gradio:run-history-change";
+function notify_run_history_change() {
+	if (typeof window === "undefined") return;
+	try {
+		window.dispatchEvent(new Event(CHANGE_EVENT));
+	} catch {}
+}
+/**
+* Subscribes to runs being added, deleted or cleared. `storage` covers other
+* tabs; the custom event covers this one, which `storage` never fires for.
+* Only counts change, not per-run progress, so listeners stay cheap.
+*
+* @returns a function that unsubscribes.
+*/
+function on_run_history_change_impl(listener) {
+	if (typeof window === "undefined") return () => {};
+	window.addEventListener(CHANGE_EVENT, listener);
+	window.addEventListener("storage", listener);
+	return () => {
+		window.removeEventListener(CHANGE_EVENT, listener);
+		window.removeEventListener("storage", listener);
+	};
+}
+function stage_run_history_replay_impl(scope, run) {
+	const key = replay_key(scope);
+	if (!key) return;
+	try {
+		window.sessionStorage.setItem(key, JSON.stringify(run));
+	} catch {}
+}
+function consume_run_history_replay_impl(scope) {
+	const key = replay_key(scope);
+	if (!key) return null;
+	try {
+		const value = window.sessionStorage.getItem(key);
+		window.sessionStorage.removeItem(key);
+		return value ? JSON.parse(value) : null;
+	} catch {
+		return null;
+	}
+}
+function restore_run_impl(config, run) {
+	const dependency = config.dependencies.find((item) => item.id === run.fn_index || typeof item.api_name === "string" && `/${item.api_name.replace(/^\//, "")}` === run.api_name);
+	if (!dependency) return false;
+	const inputs = Array.isArray(run.inputs) ? run.inputs : Object.values(run.inputs ?? {});
+	const outputs = Array.isArray(run.outputs) ? run.outputs : run.outputs === null || run.outputs === void 0 ? [] : [run.outputs];
+	const restore = (ids, saved) => {
+		for (const [index, id] of ids.entries()) {
+			const component = config.components.find((item) => item.id === id);
+			if (!component || index >= saved.length) continue;
+			if (component.type === "state") continue;
+			component.props.value = saved[index];
+		}
+	};
+	restore(dependency.inputs, inputs);
+	restore(dependency.outputs, outputs);
+	return true;
+}
+function apply_run_history_replay_impl(config) {
+	const run = consume_run_history_replay_impl(config);
+	return run ? restore_run_impl(config, run) : false;
+}
+function start_run_history_impl(options) {
+	const key = storage_key(options);
+	if (!key) return null;
+	prune_apps(key);
+	const run = {
+		id: make_id(),
+		endpoint: options.endpoint,
+		api_name: options.api_name,
+		fn_index: options.fn_index,
+		page: `${window.location.pathname}${window.location.search}`,
+		inputs: clone_for_storage(options.inputs),
+		outputs: null,
+		...options.input_components ? { input_components: clone_for_storage(options.input_components) } : {},
+		...options.output_components ? { output_components: clone_for_storage(options.output_components) } : {},
+		status: "running",
+		started_at: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	write_run_history(options, [run, ...read_run_history_impl(options)]);
+	notify_run_history_change();
+	return run.id;
+}
+function update_run_inputs_impl(scope, id, inputs) {
+	if (!id) return;
+	const runs = read_run_history_impl(scope);
+	const run = runs.find((item) => item.id === id);
+	if (!run) return;
+	run.inputs = clone_for_storage(inputs);
+	write_run_history(scope, runs);
+}
+function update_run_history_impl(scope, id, event) {
+	if (!id) return;
+	const runs = read_run_history_impl(scope);
+	const run = runs.find((item) => item.id === id);
+	if (!run) return;
+	let finished = false;
+	if (event.type === "data") {
+		run.outputs = clone_for_storage(event.data);
+		deferred_outputs.set(id, run.outputs);
+	} else if (event.type === "status" && event.original_msg === "process_starts") mark_process_start(run, event.time);
+	else if (event.type === "status" && (event.stage === "generating" || event.stage === "streaming")) run.streamed = true;
+	else if (event.type === "status" && event.stage === "complete") {
+		run.status = "completed";
+		mark_complete(run, event);
+		finished = true;
+	} else if (event.type === "status" && event.stage === "error") {
+		run.status = "failed";
+		run.error = typeof event.message === "string" ? event.message : JSON.stringify(event.message || "Unknown error");
+		mark_complete(run, event);
+		finished = true;
+	} else return;
+	if (finished) {
+		if (deferred_outputs.has(id)) run.outputs = deferred_outputs.get(id);
+		deferred_outputs.delete(id);
+		last_write.delete(id);
+	} else if (run.streamed) {
+		if (Date.now() - (last_write.get(id) ?? 0) < STREAM_WRITE_INTERVAL_MS) return;
+		last_write.set(id, Date.now());
+		deferred_outputs.delete(id);
+	}
+	write_run_history(scope, runs);
+}
+var STREAM_WRITE_INTERVAL_MS = 500;
+/** When each in-flight streamed run was last written. */
+var last_write = /* @__PURE__ */ new Map();
+/** The newest output of a streamed run that has not been written yet. */
+var deferred_outputs = /* @__PURE__ */ new Map();
+function mark_process_start(run, time) {
+	if (run.process_started_at) return;
+	const started = time || /* @__PURE__ */ new Date();
+	run.process_started_at = started.toISOString();
+	run.queued_ms = Math.max(0, started.getTime() - Date.parse(run.started_at));
+}
+function mark_complete(run, event) {
+	const completed = event.time || /* @__PURE__ */ new Date();
+	run.completed_at = completed.toISOString();
+	run.duration_ms = (!run.streamed && typeof event.cache_duration === "number" && event.cache_duration >= 0 ? event.cache_duration * 1e3 : null) ?? Math.max(0, completed.getTime() - Date.parse(run.process_started_at || run.started_at));
+}
+function read_run_history(scope) {
+	return safely(() => read_run_history_impl(scope), []);
+}
+function clear_run_history(scope) {
+	safely(() => clear_run_history_impl(scope), void 0);
+}
+function delete_run_history(scope, id) {
+	safely(() => delete_run_history_impl(scope, id), void 0);
+}
+function stage_run_history_replay(scope, run) {
+	safely(() => stage_run_history_replay_impl(scope, run), void 0);
+}
+function consume_run_history_replay(scope) {
+	return safely(() => consume_run_history_replay_impl(scope), null);
+}
+/**
+* Applies the run staged by the history page, if this page load is the one it
+* was staged for. Every entry point that renders an app has to call this, or
+* "Load run" silently does nothing on that entry point.
+*
+* @returns whether a staged run was found and applied.
+*/
+function apply_run_history_replay(config) {
+	return safely(() => apply_run_history_replay_impl(config), false);
+}
+function start_run_history(options) {
+	return safely(() => start_run_history_impl(options), null);
+}
+function update_run_inputs(scope, id, inputs) {
+	safely(() => update_run_inputs_impl(scope, id, inputs), void 0);
+}
+function update_run_history(scope, id, event) {
+	safely(() => update_run_history_impl(scope, id, event), void 0);
+}
+function on_run_history_change(listener) {
+	return safely(() => on_run_history_change_impl(() => safely(listener, void 0)), () => {});
+}
+//#endregion
 //#region src/utils/submit.ts
 function submit(endpoint, data = {}, event_data, trigger_id, all_events, additional_headers) {
 	try {
@@ -1439,9 +1740,35 @@ function submit(endpoint, data = {}, event_data, trigger_id, all_events, additio
 		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 stream;
 		let protocol = config.protocol ?? "ws";
 		if (protocol === "ws") throw new Error(WS_PROTOCOL_MSG);
+		const history_endpoint = typeof dependency.api_name === "string" ? `/${dependency.api_name}` : endpoint;
+		const history_api_name = typeof dependency.api_name === "string" ? `/${dependency.api_name}` : `Function ${fn_index}`;
+		const component_metadata = (id) => {
+			const component = config.components.find((item) => item.id === id);
+			if (!component) return null;
+			return {
+				type: component.type,
+				component_class_id: component.component_class_id,
+				props: component.props
+			};
+		};
+		const is_documented_endpoint = dependency.api_visibility === "public";
+		const history_enabled = config.run_history !== false && this.options.record_history !== false;
+		const history_scope = {
+			app_id: config.app_id,
+			username: config.username
+		};
+		const history_run_id = !history_enabled || !is_documented_endpoint ? null : start_run_history({
+			...history_scope,
+			endpoint: history_endpoint,
+			api_name: history_api_name,
+			fn_index,
+			inputs: handle_payload(resolved_data, dependency, config.components, "input", true),
+			input_components: dependency.inputs.map(component_metadata),
+			output_components: dependency.outputs.map(component_metadata)
+		});
+		let stream;
 		let event_id_final = "";
 		const _endpoint = typeof endpoint === "number" ? "/predict" : endpoint;
 		let payload;
@@ -1454,6 +1781,7 @@ function submit(endpoint, data = {}, event_data, trigger_id, all_events, additio
 			return acc;
 		}, {}) || {};
 		function fire_event(event) {
+			update_run_history(history_scope, history_run_id, event);
 			if (all_events || events_to_publish[event.type]) push_event(event);
 		}
 		async function cancel() {
@@ -1501,8 +1829,10 @@ function submit(endpoint, data = {}, event_data, trigger_id, all_events, additio
 			});
 		}
 		const job = this.handle_blob(config.root, resolved_data, endpoint_info).then(async (_payload) => {
+			let input_data = handle_payload(_payload, dependency, config.components, "input", true);
+			update_run_inputs(history_scope, history_run_id, input_data || []);
 			payload = {
-				data: handle_payload(_payload, dependency, config.components, "input", true) || [],
+				data: input_data || [],
 				event_data,
 				fn_index,
 				trigger_id,
@@ -2153,6 +2483,10 @@ var Client = class {
 	async config_success(_config) {
 		this.config = _config;
 		this.api_prefix = _config.api_prefix || "";
+		if (_config.run_history === false) clear_run_history({
+			app_id: _config.app_id,
+			username: _config.username
+		});
 		if (this.config.auth_required) return this.prepare_return_obj();
 		try {
 			this.api_info = await this.view_api();
@@ -2260,4 +2594,4 @@ async function duplicate_space(app_reference, options) {
 	return await Client.duplicate(app_reference, options);
 }
 //#endregion
-export { Client, FileData, MISSING_CREDENTIALS_MSG, client, duplicate_space as duplicate, handle_file, predict, prepare_files, submit, upload, upload_files };
+export { Client, FileData, MISSING_CREDENTIALS_MSG, apply_run_history_replay, clear_run_history, client, consume_run_history_replay, delete_run_history, duplicate_space as duplicate, handle_file, on_run_history_change, predict, prepare_files, read_run_history, run_history_url, stage_run_history_replay, submit, upload, upload_files };