Upload folder using huggingface_hub

6.0.0-dev.6/upload/package.json

@@ -0,0 +1,31 @@
+{
+	"name": "@gradio/upload",
+	"version": "0.17.2-dev.2",
+	"description": "Gradio UI packages",
+	"type": "module",
+	"main": "src/index.ts",
+	"author": "",
+	"license": "ISC",
+	"dependencies": {
+		"@gradio/atoms": "workspace:^",
+		"@gradio/icons": "workspace:^",
+		"@gradio/client": "workspace:^",
+		"@gradio/utils": "workspace:^"
+	},
+	"main_changeset": true,
+	"exports": {
+		".": {
+			"gradio": "./src/index.ts",
+			"svelte": "./dist/src/index.js",
+			"types": "./dist/src/index.d.ts"
+		}
+	},
+	"peerDependencies": {
+		"svelte": "^5.43.4"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "js/upload"
+	}
+}

6.0.0-dev.6/upload/src/ModifyUpload.svelte

@@ -0,0 +1,54 @@
+<script lang="ts">
+	import { IconButton, IconButtonWrapper } from "@gradio/atoms";
+	import type { I18nFormatter } from "@gradio/utils";
+	import { Edit, Clear, Undo, Download } from "@gradio/icons";
+	import { DownloadLink } from "@gradio/atoms";
+
+	import { createEventDispatcher } from "svelte";
+
+	export let editable = false;
+	export let undoable = false;
+	export let download: string | null = null;
+	export let i18n: I18nFormatter;
+
+	const dispatch = createEventDispatcher<{
+		edit?: never;
+		clear?: never;
+		undo?: never;
+	}>();
+</script>
+
+<IconButtonWrapper>
+	{#if editable}
+		<IconButton
+			Icon={Edit}
+			label={i18n("common.edit")}
+			on:click={() => dispatch("edit")}
+		/>
+	{/if}
+
+	{#if undoable}
+		<IconButton
+			Icon={Undo}
+			label={i18n("common.undo")}
+			on:click={() => dispatch("undo")}
+		/>
+	{/if}
+
+	{#if download}
+		<DownloadLink href={download} download>
+			<IconButton Icon={Download} label={i18n("common.download")} />
+		</DownloadLink>
+	{/if}
+
+	<slot />
+
+	<IconButton
+		Icon={Clear}
+		label={i18n("common.clear")}
+		on:click={(event) => {
+			dispatch("clear");
+			event.stopPropagation();
+		}}
+	/>
+</IconButtonWrapper>

6.0.0-dev.6/upload/src/Upload.svelte

@@ -0,0 +1,376 @@
+<script lang="ts">
+	import { createEventDispatcher, tick, getContext } from "svelte";
+	import type { FileData } from "@gradio/client";
+	import { prepare_files, type Client } from "@gradio/client";
+	import UploadProgress from "./UploadProgress.svelte";
+	import { create_drag } from "./utils";
+
+	const { drag, open_file_upload: _open_file_upload } = create_drag();
+
+	export let filetype: string | string[] | null = null;
+	export let dragging = false;
+	export let boundedheight = true;
+	export let center = true;
+	export let flex = true;
+	export let file_count: "single" | "multiple" | "directory" = "single";
+	export let disable_click = false;
+	export let root: string;
+	export let hidden = false;
+	export let format: "blob" | "file" = "file";
+	export let uploading = false;
+	export let show_progress = true;
+	export let max_file_size: number | null = null;
+	export let upload: Client["upload"];
+	export let stream_handler: Client["stream"];
+	export let icon_upload = false;
+	export let height: number | string | undefined = undefined;
+	export let aria_label: string | undefined = undefined;
+	export let upload_promise: Promise<(FileData | null)[]> | null = null;
+
+	export function open_upload(): void {
+		_open_file_upload();
+	}
+	let upload_id: string = "";
+	let file_data: FileData[];
+	let accept_file_types: string | null;
+	let use_post_upload_validation: boolean | null = null;
+
+	const get_ios = (): boolean => {
+		if (typeof navigator !== "undefined") {
+			const userAgent = navigator.userAgent.toLowerCase();
+			return userAgent.indexOf("iphone") > -1 || userAgent.indexOf("ipad") > -1;
+		}
+		return false;
+	};
+
+	$: ios = get_ios();
+
+	const dispatch = createEventDispatcher();
+	const validFileTypes = ["image", "video", "audio", "text", "file"];
+	const process_file_type = (type: string): string => {
+		if (ios && type.startsWith(".")) {
+			use_post_upload_validation = true;
+			return type;
+		}
+		if (ios && type.includes("file/*")) {
+			return "*";
+		}
+		if (type.startsWith(".") || type.endsWith("/*")) {
+			return type;
+		}
+		if (validFileTypes.includes(type)) {
+			return type + "/*";
+		}
+		return "." + type;
+	};
+
+	$: if (filetype == null) {
+		accept_file_types = null;
+	} else if (typeof filetype === "string") {
+		accept_file_types = process_file_type(filetype);
+	} else if (ios && filetype.includes("file/*")) {
+		accept_file_types = "*";
+	} else {
+		filetype = filetype.map(process_file_type);
+		accept_file_types = filetype.join(", ");
+	}
+
+	export function paste_clipboard(): void {
+		navigator.clipboard.read().then(async (items) => {
+			for (let i = 0; i < items.length; i++) {
+				const type = items[i].types.find((t) => t.startsWith("image/"));
+				if (type) {
+					items[i].getType(type).then(async (blob) => {
+						const file = new File(
+							[blob],
+							`clipboard.${type.replace("image/", "")}`
+						);
+						await load_files([file]);
+					});
+					break;
+				}
+			}
+		});
+	}
+
+	export function open_file_upload(): void {
+		_open_file_upload();
+	}
+
+	function handle_upload(
+		file_data: FileData[],
+		_upload_id?: string
+	): Promise<(FileData | null)[]> {
+		upload_promise = new Promise(async (resolve, rej) => {
+			await tick();
+			if (!_upload_id) {
+				upload_id = Math.random().toString(36).substring(2, 15);
+			} else {
+				upload_id = _upload_id;
+			}
+
+			uploading = true;
+
+			try {
+				const _file_data = await upload(
+					file_data,
+					root,
+					upload_id,
+					max_file_size ?? Infinity
+				);
+				dispatch(
+					"load",
+					file_count === "single" ? _file_data?.[0] : _file_data
+				);
+				resolve(_file_data || []);
+				uploading = false;
+				return _file_data || [];
+			} catch (e) {
+				dispatch("error", (e as Error).message);
+				uploading = false;
+				resolve([]);
+			}
+		});
+
+		return upload_promise;
+	}
+
+	function is_valid_mimetype(
+		file_accept: string | string[] | null,
+		uploaded_file_extension: string,
+		uploaded_file_type: string
+	): boolean {
+		if (
+			!file_accept ||
+			file_accept === "*" ||
+			file_accept === "file/*" ||
+			(Array.isArray(file_accept) &&
+				file_accept.some((accept) => accept === "*" || accept === "file/*"))
+		) {
+			return true;
+		}
+		let acceptArray: string[];
+		if (typeof file_accept === "string") {
+			acceptArray = file_accept.split(",").map((s) => s.trim());
+		} else if (Array.isArray(file_accept)) {
+			acceptArray = file_accept;
+		} else {
+			return false;
+		}
+
+		return (
+			acceptArray.includes(uploaded_file_extension) ||
+			acceptArray.some((type) => {
+				const [category] = type.split("/").map((s) => s.trim());
+				return (
+					type.endsWith("/*") && uploaded_file_type.startsWith(category + "/")
+				);
+			})
+		);
+	}
+
+	export async function load_files(
+		files: File[] | Blob[],
+		upload_id?: string
+	): Promise<(FileData | null)[] | void> {
+		if (!files.length) {
+			return;
+		}
+		let _files: File[] = files.map(
+			(f) =>
+				new File([f], f instanceof File ? f.name : "file", { type: f.type })
+		);
+
+		if (ios && use_post_upload_validation) {
+			_files = _files.filter((file) => {
+				if (is_valid_file(file)) {
+					return true;
+				}
+				dispatch(
+					"error",
+					`Invalid file type: ${file.name}. Only ${filetype} allowed.`
+				);
+				return false;
+			});
+
+			if (_files.length === 0) {
+				return [];
+			}
+		}
+
+		file_data = await prepare_files(_files);
+		return await handle_upload(file_data, upload_id);
+	}
+
+	function is_valid_file(file: File): boolean {
+		if (!filetype) return true;
+
+		const allowed_types = Array.isArray(filetype) ? filetype : [filetype];
+
+		return allowed_types.some((type) => {
+			const processed_type = process_file_type(type);
+
+			if (processed_type.startsWith(".")) {
+				return file.name.toLowerCase().endsWith(processed_type.toLowerCase());
+			}
+
+			if (processed_type === "*") {
+				return true;
+			}
+
+			if (processed_type.endsWith("/*")) {
+				const [category] = processed_type.split("/");
+				return file.type.startsWith(category + "/");
+			}
+
+			return file.type === processed_type;
+		});
+	}
+
+	async function load_files_from_upload(files: File[]): Promise<void> {
+		const files_to_load = files.filter((file) => {
+			const file_extension = "." + file.name.toLowerCase().split(".").pop();
+			if (
+				file_extension &&
+				is_valid_mimetype(accept_file_types, file_extension, file.type)
+			) {
+				return true;
+			}
+			if (
+				file_extension && Array.isArray(filetype)
+					? filetype.includes(file_extension)
+					: file_extension === filetype
+			) {
+				return true;
+			}
+			dispatch("error", `Invalid file type only ${filetype} allowed.`);
+			return false;
+		});
+		if (format != "blob") {
+			await load_files(files_to_load);
+		} else {
+			if (file_count === "single") {
+				dispatch("load", files_to_load[0]);
+				return;
+			}
+			dispatch("load", files_to_load);
+		}
+	}
+
+	export async function load_files_from_drop(e: DragEvent): Promise<void> {
+		dragging = false;
+		if (!e.dataTransfer?.files) return;
+		const files_to_load = Array.from(e.dataTransfer.files).filter(
+			is_valid_file
+		);
+
+		if (format != "blob") {
+			await load_files(files_to_load);
+		} else {
+			if (file_count === "single") {
+				dispatch("load", files_to_load[0]);
+				return;
+			}
+			dispatch("load", files_to_load);
+		}
+	}
+</script>
+
+{#if filetype === "clipboard"}
+	<button
+		class:hidden
+		class:center
+		class:boundedheight
+		class:flex
+		class:icon-mode={icon_upload}
+		style:height={icon_upload
+			? ""
+			: height
+				? typeof height === "number"
+					? height + "px"
+					: height
+				: "100%"}
+		tabindex={hidden ? -1 : 0}
+		on:click={paste_clipboard}
+		aria-label={aria_label || "Paste from clipboard"}
+	>
+		<slot />
+	</button>
+{:else if uploading && show_progress}
+	{#if !hidden}
+		<UploadProgress {root} {upload_id} files={file_data} {stream_handler} />
+	{/if}
+{:else}
+	<button
+		class:hidden
+		class:center
+		class:boundedheight
+		class:flex
+		class:disable_click
+		class:icon-mode={icon_upload}
+		style:height={icon_upload
+			? ""
+			: height
+				? typeof height === "number"
+					? height + "px"
+					: height
+				: "100%"}
+		tabindex={hidden ? -1 : 0}
+		use:drag={{
+			on_drag_change: (dragging) => (dragging = dragging),
+			on_files: (files) => load_files_from_upload(files),
+			accepted_types: accept_file_types,
+			mode: file_count,
+			disable_click
+		}}
+		aria-label={aria_label || "Click to upload or drop files"}
+		aria-dropeffect="copy"
+	>
+		<slot />
+	</button>
+{/if}
+
+<style>
+	button {
+		cursor: pointer;
+		width: var(--size-full);
+	}
+
+	.center {
+		display: flex;
+		justify-content: center;
+	}
+	.flex {
+		display: flex;
+		flex-direction: column;
+		justify-content: center;
+		align-items: center;
+	}
+	.hidden {
+		display: none;
+		position: absolute;
+		flex-grow: 0;
+	}
+
+	.hidden :global(svg) {
+		display: none;
+	}
+
+	.disable_click {
+		cursor: default;
+	}
+
+	.icon-mode {
+		position: absolute !important;
+		width: var(--size-4);
+		height: var(--size-4);
+		padding: 0;
+		min-height: 0;
+		border-radius: var(--radius-circle);
+	}
+
+	.icon-mode :global(svg) {
+		width: var(--size-4);
+		height: var(--size-4);
+	}
+</style>

6.0.0-dev.6/upload/src/UploadProgress.svelte

@@ -0,0 +1,189 @@
+<script lang="ts">
+	import { FileData, type Client } from "@gradio/client";
+	import { onMount, createEventDispatcher, onDestroy } from "svelte";
+
+	type FileDataWithProgress = FileData & { progress: number };
+
+	export let upload_id: string;
+	export let root: string;
+	export let files: FileData[];
+	export let stream_handler: Client["stream"];
+
+	let stream: Awaited<ReturnType<Client["stream"]>>;
+	let progress = false;
+	let current_file_upload: FileDataWithProgress;
+	let file_to_display: FileDataWithProgress;
+
+	let files_with_progress: FileDataWithProgress[] = files.map((file) => {
+		return {
+			...file,
+			progress: 0
+		};
+	});
+
+	const dispatch = createEventDispatcher();
+
+	function handleProgress(filename: string, chunk_size: number): void {
+		// Find the corresponding file in the array and update its progress
+		files_with_progress = files_with_progress.map((file) => {
+			if (file.orig_name === filename) {
+				file.progress += chunk_size;
+			}
+			return file;
+		});
+	}
+
+	function getProgress(file: FileDataWithProgress): number {
+		return (file.progress * 100) / (file.size || 0) || 0;
+	}
+
+	onMount(async () => {
+		stream = await stream_handler(
+			new URL(`${root}/gradio_api/upload_progress?upload_id=${upload_id}`)
+		);
+
+		if (stream == null) {
+			throw new Error("Event source is not defined");
+		}
+		// Event listener for progress updates
+		stream.onmessage = async function (event) {
+			const _data = JSON.parse(event.data);
+			if (!progress) progress = true;
+			if (_data.msg === "done") {
+				// the stream will close itself but is here for clarity; remove .close() in 5.0
+				stream?.close();
+				dispatch("done");
+			} else {
+				current_file_upload = _data;
+				handleProgress(_data.orig_name, _data.chunk_size);
+			}
+		};
+	});
+	onDestroy(() => {
+		// the stream will close itself but is here for clarity; remove .close() in 5.0
+		if (stream != null || stream != undefined) stream.close();
+	});
+
+	function calculateTotalProgress(files: FileData[]): number {
+		let totalProgress = 0;
+		files.forEach((file) => {
+			totalProgress += getProgress(file as FileDataWithProgress);
+		});
+
+		document.documentElement.style.setProperty(
+			"--upload-progress-width",
+			(totalProgress / files.length).toFixed(2) + "%"
+		);
+
+		return totalProgress / files.length;
+	}
+
+	$: calculateTotalProgress(files_with_progress);
+
+	$: file_to_display = current_file_upload || files_with_progress[0];
+</script>
+
+<div class="wrap" class:progress>
+	<span class="uploading"
+		>Uploading {files_with_progress.length}
+		{files_with_progress.length > 1 ? "files" : "file"}...</span
+	>
+
+	{#if file_to_display}
+		<div class="file">
+			<span>
+				<div class="progress-bar">
+					<progress
+						style="visibility:hidden;height:0;width:0;"
+						value={getProgress(file_to_display)}
+						max="100">{getProgress(file_to_display)}</progress
+					>
+				</div>
+			</span>
+			<span class="file-name">
+				{file_to_display.orig_name}
+			</span>
+		</div>
+	{/if}
+</div>
+
+<style>
+	.wrap {
+		overflow-y: auto;
+		transition: opacity 0.5s ease-in-out;
+		background: var(--block-background-fill);
+		position: relative;
+		display: flex;
+		flex-direction: column;
+		align-items: center;
+		justify-content: center;
+		min-height: var(--size-40);
+		width: var(--size-full);
+	}
+
+	.wrap::after {
+		content: "";
+		position: absolute;
+		top: 0;
+		left: 0;
+		width: var(--upload-progress-width);
+		height: 100%;
+		transition: all 0.5s ease-in-out;
+		z-index: 1;
+	}
+
+	.uploading {
+		font-size: var(--text-lg);
+		font-family: var(--font);
+		z-index: 2;
+	}
+
+	.file-name {
+		margin: var(--spacing-md);
+		font-size: var(--text-lg);
+		color: var(--body-text-color-subdued);
+	}
+
+	.file {
+		font-size: var(--text-md);
+		z-index: 2;
+		display: flex;
+		align-items: center;
+	}
+
+	.file progress {
+		display: inline;
+		height: var(--size-1);
+		width: 100%;
+		transition: all 0.5s ease-in-out;
+		color: var(--color-accent);
+		border: none;
+	}
+
+	.file progress[value]::-webkit-progress-value {
+		background-color: var(--color-accent);
+		border-radius: 20px;
+	}
+
+	.file progress[value]::-webkit-progress-bar {
+		background-color: var(--border-color-accent);
+		border-radius: 20px;
+	}
+
+	.progress-bar {
+		width: 14px;
+		height: 14px;
+		border-radius: 50%;
+		background:
+			radial-gradient(
+				closest-side,
+				var(--block-background-fill) 64%,
+				transparent 53% 100%
+			),
+			conic-gradient(
+				var(--color-accent) var(--upload-progress-width),
+				var(--border-color-accent) 0
+			);
+		transition: all 0.5s ease-in-out;
+	}
+</style>

6.0.0-dev.6/upload/src/index.ts

@@ -0,0 +1,4 @@
+export { default as Upload } from "./Upload.svelte";
+export { default as ModifyUpload } from "./ModifyUpload.svelte";
+export { default as UploadProgress } from "./UploadProgress.svelte";
+export { create_drag } from "./utils";

6.0.0-dev.6/upload/src/utils.ts

@@ -0,0 +1,141 @@
+interface DragActionOptions {
+	disable_click?: boolean;
+	accepted_types?: string | string[] | null;
+	mode?: "single" | "multiple" | "directory";
+	on_drag_change?: (dragging: boolean) => void;
+	on_files?: (files: File[]) => void;
+}
+
+type ActionReturn = {
+	update: (new_options: DragActionOptions) => void;
+	destroy: () => void;
+};
+
+export function create_drag(): {
+	drag: (node: HTMLElement, options: DragActionOptions) => ActionReturn;
+	open_file_upload: () => void;
+} {
+	let hidden_input: HTMLInputElement;
+	let _options: DragActionOptions;
+	return {
+		drag(
+			node: HTMLElement,
+			options: DragActionOptions = {}
+		): {
+			update: (new_options: DragActionOptions) => void;
+			destroy: () => void;
+		} {
+			_options = options;
+
+			// Create and configure hidden file input
+			function setup_hidden_input(): void {
+				hidden_input = document.createElement("input");
+				hidden_input.type = "file";
+				hidden_input.style.display = "none";
+				hidden_input.setAttribute("aria-label", "File upload");
+				hidden_input.setAttribute("data-testid", "file-upload");
+				const accept_options = Array.isArray(_options.accepted_types)
+					? _options.accepted_types.join(",")
+					: _options.accepted_types || undefined;
+
+				if (accept_options) {
+					hidden_input.accept = accept_options;
+				}
+
+				hidden_input.multiple = _options.mode === "multiple" || false;
+				if (_options.mode === "directory") {
+					hidden_input.webkitdirectory = true;
+					hidden_input.setAttribute("directory", "");
+					hidden_input.setAttribute("mozdirectory", "");
+				}
+				node.appendChild(hidden_input);
+			}
+
+			setup_hidden_input();
+
+			function handle_drag(e: DragEvent): void {
+				e.preventDefault();
+				e.stopPropagation();
+			}
+
+			function handle_drag_enter(e: DragEvent): void {
+				e.preventDefault();
+				e.stopPropagation();
+				_options.on_drag_change?.(true);
+			}
+
+			function handle_drag_leave(e: DragEvent): void {
+				e.preventDefault();
+				e.stopPropagation();
+				_options.on_drag_change?.(false);
+			}
+
+			function handle_drop(e: DragEvent): void {
+				e.preventDefault();
+				e.stopPropagation();
+				_options.on_drag_change?.(false);
+
+				if (!e.dataTransfer?.files) return;
+				const files = Array.from(e.dataTransfer.files);
+				if (files.length > 0) {
+					_options.on_files?.(files);
+				}
+			}
+
+			function handle_click(): void {
+				if (!_options.disable_click) {
+					hidden_input.value = "";
+					hidden_input.click();
+				}
+			}
+
+			function handle_file_input_change(): void {
+				if (hidden_input.files) {
+					const files = Array.from(hidden_input.files);
+					if (files.length > 0) {
+						_options.on_files?.(files);
+					}
+				}
+			}
+
+			// Add all event listeners
+			node.addEventListener("drag", handle_drag);
+			node.addEventListener("dragstart", handle_drag);
+			node.addEventListener("dragend", handle_drag);
+			node.addEventListener("dragover", handle_drag);
+			node.addEventListener("dragenter", handle_drag_enter);
+			node.addEventListener("dragleave", handle_drag_leave);
+			node.addEventListener("drop", handle_drop);
+			node.addEventListener("click", handle_click);
+			hidden_input!.addEventListener("change", handle_file_input_change);
+
+			return {
+				update(new_options: DragActionOptions) {
+					_options = new_options;
+					// Recreate hidden input with new options
+					hidden_input.remove();
+					setup_hidden_input();
+					hidden_input.addEventListener("change", handle_file_input_change);
+				},
+				destroy() {
+					node.removeEventListener("drag", handle_drag);
+					node.removeEventListener("dragstart", handle_drag);
+					node.removeEventListener("dragend", handle_drag);
+					node.removeEventListener("dragover", handle_drag);
+					node.removeEventListener("dragenter", handle_drag_enter);
+					node.removeEventListener("dragleave", handle_drag_leave);
+					node.removeEventListener("drop", handle_drop);
+					node.removeEventListener("click", handle_click);
+					hidden_input.removeEventListener("change", handle_file_input_change);
+					hidden_input.remove();
+				}
+			};
+		},
+		open_file_upload(): void {
+			if (hidden_input) {
+				hidden_input.value = "";
+				hidden_input.click();
+			}
+		}
+	};
+}