@gradio/client 0.16.0 → 0.18.0

package/src/helpers/spaces.ts

@@ -0,0 +1,197 @@
+import {
+	RUNTIME_URL,
+	SLEEPTIME_URL,
+	SPACE_STATUS_ERROR_MSG
+} from "../constants";
+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: "",
+				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;
+		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;
+	}
+}
+
+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 (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;

package/src/index.ts

@@ -1,11 +1,17 @@
-export {
-	client,
-	post_data,
-	upload_files,
-	duplicate,
-	api_factory
-} from "./client.js";
-export type { client_return } from "./client.js";
-export type { SpaceStatus } from "./types.js";
+export { Client } from "./client";
 
-export { FileData, upload, prepare_files } from "./upload.js";
+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 type {
+	SpaceStatus,
+	Status,
+	client_return,
+	UploadResponse
+} from "./types";
+
+// todo: remove in @gradio/client v1.0
+export { client } from "./client";
+export { duplicate_space as duplicate } from "./client";

package/src/test/api_info.test.ts

@@ -0,0 +1,456 @@
+import { QUEUE_FULL_MSG, SPACE_METADATA_ERROR_MSG } from "../constants";
+import { beforeAll, afterEach, afterAll, it, expect, describe } from "vitest";
+import {
+	handle_message,
+	get_description,
+	get_type,
+	process_endpoint
+} from "../helpers/api_info";
+import { initialise_server } from "./server";
+
+const server = initialise_server();
+
+beforeAll(() => server.listen());
+afterEach(() => server.resetHandlers());
+afterAll(() => server.close());
+
+describe("handle_message", () => {
+	it("should return type 'data' when msg is 'send_data'", () => {
+		const data = { msg: "send_data" };
+		const last_status = "pending";
+		const result = handle_message(data, last_status);
+		expect(result).toEqual({ type: "data" });
+	});
+
+	it("should return type 'hash' when msg is 'send_hash'", () => {
+		const data = { msg: "send_hash" };
+		const last_status = "pending";
+		const result = handle_message(data, last_status);
+		expect(result).toEqual({ type: "hash" });
+	});
+
+	it("should return type 'update' with queue full message when msg is 'queue_full'", () => {
+		const data = { msg: "queue_full", code: 500, success: false };
+		const last_status = "pending";
+		const result = handle_message(data, last_status);
+		expect(result).toEqual({
+			type: "update",
+			status: {
+				queue: true,
+				message: QUEUE_FULL_MSG,
+				stage: "error",
+				code: 500,
+				success: false
+			}
+		});
+	});
+
+	it("should return type 'heartbeat' when msg is 'heartbeat'", () => {
+		const data = { msg: "heartbeat" };
+		const last_status = "pending";
+		const result = handle_message(data, last_status);
+		expect(result).toEqual({ type: "heartbeat" });
+	});
+
+	it("should return type 'unexpected_error' with error message when msg is 'unexpected_error'", () => {
+		const data = { msg: "unexpected_error", message: "Something went wrong" };
+		const last_status = "pending";
+		const result = handle_message(data, last_status);
+		expect(result).toEqual({
+			type: "unexpected_error",
+			status: {
+				queue: true,
+				message: "Something went wrong",
+				stage: "error",
+				success: false
+			}
+		});
+	});
+
+	it("should return type 'update' with estimation status when msg is 'estimation'", () => {
+		const data = {
+			msg: "estimation",
+			code: 200,
+			queue_size: 10,
+			rank: 5,
+			rank_eta: 60,
+			success: true
+		};
+		const last_status = "pending";
+		const result = handle_message(data, last_status);
+		expect(result).toEqual({
+			type: "update",
+			status: {
+				queue: true,
+				stage: "pending",
+				code: 200,
+				size: 10,
+				position: 5,
+				eta: 60,
+				success: true
+			}
+		});
+	});
+
+	it("should return type 'update' with progress status when msg is 'progress'", () => {
+		const data = {
+			msg: "progress",
+			code: 200,
+			progress_data: { current: 50, total: 100 },
+			success: true
+		};
+		const last_status = "pending";
+		const result = handle_message(data, last_status);
+		expect(result).toEqual({
+			type: "update",
+			status: {
+				queue: true,
+				stage: "pending",
+				code: 200,
+				progress_data: { current: 50, total: 100 },
+				success: true
+			}
+		});
+	});
+
+	it("should return type 'log' with the provided data when msg is 'log'", () => {
+		const data = { msg: "log", log_data: "Some log message" };
+		const last_status = "pending";
+		const result = handle_message(data, last_status);
+		expect(result).toEqual({
+			type: "log",
+			data: { msg: "log", log_data: "Some log message" }
+		});
+	});
+
+	it("should return type 'generating' with generating status when msg is 'process_generating' and success is true", () => {
+		const data = {
+			msg: "process_generating",
+			success: true,
+			code: 200,
+			progress_data: { current: 50, total: 100 },
+			average_duration: 120,
+			output: { result: "Some result" }
+		};
+		const last_status = "pending";
+		const result = handle_message(data, last_status);
+		expect(result).toEqual({
+			type: "generating",
+			status: {
+				queue: true,
+				message: null,
+				stage: "generating",
+				code: 200,
+				progress_data: { current: 50, total: 100 },
+				eta: 120
+			},
+			data: { result: "Some result" }
+		});
+	});
+
+	it("should return type 'update' with error status when msg is 'process_generating' and success is false", () => {
+		const data = {
+			msg: "process_generating",
+			success: false,
+			code: 500,
+			progress_data: { current: 50, total: 100 },
+			average_duration: 120,
+			output: { error: "Error" }
+		};
+		const last_status = "pending";
+		const result = handle_message(data, last_status);
+
+		expect(result).toEqual({
+			type: "generating",
+			data: null,
+			status: {
+				eta: 120,
+				queue: true,
+				message: "Error",
+				stage: "error",
+				code: 500,
+				progress_data: { current: 50, total: 100 }
+			}
+		});
+	});
+
+	it("should return type 'complete' with success status when msg is 'process_completed' and success is true", () => {
+		const data = {
+			msg: "process_completed",
+			success: true,
+			code: 200,
+			progress_data: { current: 100, total: 100 },
+			output: { result: "Some result" }
+		};
+		const last_status = "pending";
+		const result = handle_message(data, last_status);
+		expect(result).toEqual({
+			type: "complete",
+			status: {
+				queue: true,
+				message: undefined,
+				stage: "complete",
+				code: 200,
+				progress_data: { current: 100, total: 100 }
+			},
+			data: { result: "Some result" }
+		});
+	});
+
+	it("should return type 'update' with error status when msg is 'process_completed' and success is false", () => {
+		const data = {
+			msg: "process_completed",
+			success: false,
+			code: 500,
+			progress_data: { current: 100, total: 100 },
+			output: { error: "Some error message" }
+		};
+		const last_status = "pending";
+		const result = handle_message(data, last_status);
+		expect(result).toEqual({
+			type: "update",
+			status: {
+				queue: true,
+				message: "Some error message",
+				stage: "error",
+				code: 500,
+				success: false
+			}
+		});
+	});
+
+	it("should return type 'update' with pending status when msg is 'process_starts'", () => {
+		const data = {
+			msg: "process_starts",
+			code: 200,
+			rank: 5,
+			success: true,
+			eta: 60
+		};
+		const last_status = "pending";
+		const result = handle_message(data, last_status);
+		expect(result).toEqual({
+			type: "update",
+			status: {
+				queue: true,
+				stage: "pending",
+				code: 200,
+				size: 5,
+				position: 0,
+				success: true,
+				eta: 60
+			}
+		});
+	});
+
+	it("should return type 'none' with error status when msg is unknown", () => {
+		const data = { msg: "unknown" };
+		const last_status = "pending";
+		const result = handle_message(data, last_status);
+		expect(result).toEqual({
+			type: "none",
+			status: { stage: "error", queue: true }
+		});
+	});
+});
+
+describe("get_description", () => {
+	it("should return 'array of [file, label] tuples' when serializer is 'GallerySerializable'", () => {
+		const type = { type: "string", description: "param description" };
+		const serializer = "GallerySerializable";
+		const result = get_description(type, serializer);
+		expect(result).toEqual("array of [file, label] tuples");
+	});
+
+	it("should return 'array of strings' when serializer is 'ListStringSerializable'", () => {
+		const type = { type: "string", description: "param description" };
+		const serializer = "ListStringSerializable";
+		const result = get_description(type, serializer);
+		expect(result).toEqual("array of strings");
+	});
+
+	it("should return 'array of files or single file' when serializer is 'FileSerializable'", () => {
+		const type = { type: "string", description: "param description" };
+		const serializer = "FileSerializable";
+		const result = get_description(type, serializer);
+		expect(result).toEqual("array of files or single file");
+	});
+
+	it("should return the type's description when serializer is not 'GallerySerializable', 'ListStringSerializable', or 'FileSerializable'", () => {
+		const type = { type: "string", description: "param description" };
+		const serializer = "SomeOtherSerializer";
+		const result = get_description(type, serializer);
+		expect(result).toEqual(type.description);
+	});
+});
+
+describe("get_type", () => {
+	it("should return 'string' when type is 'string'", () => {
+		const type = { type: "string", description: "param description" };
+		const component = "Component";
+		const serializer = "Serializer";
+		const signature_type = "parameter";
+		const result = get_type(type, component, serializer, signature_type);
+		expect(result).toEqual("string");
+	});
+
+	it("should return 'boolean' when type is 'boolean'", () => {
+		const type = { type: "boolean", description: "param description" };
+		const component = "Component";
+		const serializer = "Serializer";
+		const signature_type = "parameter";
+		const result = get_type(type, component, serializer, signature_type);
+		expect(result).toEqual("boolean");
+	});
+
+	it("should return 'number' when type is 'number'", () => {
+		const type = { type: "number", description: "param description" };
+		const component = "Component";
+		const serializer = "Serializer";
+		const signature_type = "parameter";
+		const result = get_type(type, component, serializer, signature_type);
+		expect(result).toEqual("number");
+	});
+
+	it("should return 'any' when serializer is 'JSONSerializable'", () => {
+		const type = { type: "any", description: "param description" };
+		const component = "Component";
+		const serializer = "JSONSerializable";
+		const signature_type = "parameter";
+		const result = get_type(type, component, serializer, signature_type);
+		expect(result).toEqual("any");
+	});
+
+	it("should return 'any' when serializer is 'StringSerializable'", () => {
+		const type = { type: "any", description: "param description" };
+		const component = "Component";
+		const serializer = "StringSerializable";
+		const signature_type = "parameter";
+		const result = get_type(type, component, serializer, signature_type);
+		expect(result).toEqual("any");
+	});
+
+	it("should return 'string[]' when serializer is 'ListStringSerializable'", () => {
+		const type = { type: "any", description: "param description" };
+		const component = "Component";
+		const serializer = "ListStringSerializable";
+		const signature_type = "parameter";
+		const result = get_type(type, component, serializer, signature_type);
+		expect(result).toEqual("string[]");
+	});
+
+	it("should return 'Blob | File | Buffer' when component is 'Image' and signature_type is 'parameter'", () => {
+		const type = { type: "any", description: "param description" };
+		const component = "Image";
+		const serializer = "Serializer";
+		const signature_type = "parameter";
+		const result = get_type(type, component, serializer, signature_type);
+		expect(result).toEqual("Blob | File | Buffer");
+	});
+
+	it("should return 'string' when component is 'Image' and signature_type is 'return'", () => {
+		const type = { type: "string", description: "param description" };
+		const component = "Image";
+		const serializer = "Serializer";
+		const signature_type = "return";
+		const result = get_type(type, component, serializer, signature_type);
+		expect(result).toEqual("string");
+	});
+
+	it("should return '(Blob | File | Buffer)[]' when serializer is 'FileSerializable' and type is an array and signature_type is 'parameter'", () => {
+		const type = { type: "array", description: "param description" };
+		const component = "Component";
+		const serializer = "FileSerializable";
+		const signature_type = "parameter";
+		const result = get_type(type, component, serializer, signature_type);
+		expect(result).toEqual("(Blob | File | Buffer)[]");
+	});
+
+	it("should return 'Blob | File | Buffer' when serializer is 'FileSerializable' and type is not an array and signature_type is 'return'", () => {
+		const type = { type: "any", description: "param description" };
+		const component = "Component";
+		const serializer = "FileSerializable";
+		const signature_type = "return";
+		const result = get_type(type, component, serializer, signature_type);
+		expect(result).toEqual(
+			"{ name: string; data: string; size?: number; is_file?: boolean; orig_name?: string}"
+		);
+	});
+
+	it("should return a FileData object when serializer is 'FileSerializable' and type is not an array and signature_type is 'return'", () => {
+		const type = { type: "any", description: "param description" };
+		const component = "Component";
+		const serializer = "FileSerializable";
+		const signature_type = "return";
+		const result = get_type(type, component, serializer, signature_type);
+		expect(result).toEqual(
+			"{ name: string; data: string; size?: number; is_file?: boolean; orig_name?: string}"
+		);
+	});
+
+	it("should return '[(Blob | File | Buffer), (string | null)][]' when serializer is 'GallerySerializable' and signature_type is 'parameter'", () => {
+		const type = { type: "any", description: "param description" };
+		const component = "Component";
+		const serializer = "GallerySerializable";
+		const signature_type = "parameter";
+		const result = get_type(type, component, serializer, signature_type);
+		expect(result).toEqual("[(Blob | File | Buffer), (string | null)][]");
+	});
+
+	it("should return a FileData object when serializer is 'GallerySerializable' and signature_type is 'return'", () => {
+		const type = { type: "any", description: "param description" };
+		const component = "Component";
+		const serializer = "GallerySerializable";
+		const signature_type = "return";
+		const result = get_type(type, component, serializer, signature_type);
+		expect(result).toEqual(
+			"[{ name: string; data: string; size?: number; is_file?: boolean; orig_name?: string}, (string | null))][]"
+		);
+	});
+});
+
+describe("process_endpoint", () => {
+	it("should return space_id, host, ws_protocol, and http_protocol when app_reference is a valid space name", async () => {
+		const app_reference = "hmb/hello_world";
+		const host = "hmb-hello-world.hf.space";
+
+		const hf_token = "hf_token";
+		const expected = {
+			space_id: app_reference,
+			host,
+			ws_protocol: "wss",
+			http_protocol: "https:"
+		};
+
+		const result = await process_endpoint(app_reference, hf_token);
+		expect(result).toEqual(expected);
+	});
+
+	it("should throw an error when fetching space metadata fails", async () => {
+		const app_reference = "hmb/bye_world";
+		const hf_token = "hf_token";
+
+		try {
+			await process_endpoint(app_reference, hf_token);
+		} catch (error) {
+			expect(error.message).toEqual(
+				SPACE_METADATA_ERROR_MSG + "Unexpected end of JSON input"
+			);
+		}
+	});
+
+	it("should return the correct data when app_reference is a valid space domain", async () => {
+		const app_reference = "hmb/hello_world";
+		const host = "hmb-hello-world.hf.space";
+
+		const expected = {
+			space_id: app_reference,
+			host,
+			ws_protocol: "wss",
+			http_protocol: "https:"
+		};
+
+		const result = await process_endpoint("hmb/hello_world");
+		expect(result).toEqual(expected);
+	});
+});