Add files using upload-large-folder tool

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/audio/interactive/InteractiveAudio.svelte

@@ -0,0 +1,332 @@
+<script lang="ts">
+	import { onDestroy, createEventDispatcher, tick } from "svelte";
+	import { Upload, ModifyUpload } from "@gradio/upload";
+	import { prepare_files, type FileData, type Client } from "@gradio/client";
+	import { BlockLabel } from "@gradio/atoms";
+	import { Music } from "@gradio/icons";
+	import { StreamingBar } from "@gradio/statustracker";
+	import AudioPlayer from "../player/AudioPlayer.svelte";
+
+	import type { IBlobEvent, IMediaRecorder } from "extendable-media-recorder";
+	import type { I18nFormatter } from "js/core/src/gradio_helper";
+	import AudioRecorder from "../recorder/AudioRecorder.svelte";
+	import StreamAudio from "../streaming/StreamAudio.svelte";
+	import { SelectSource } from "@gradio/atoms";
+	import type { WaveformOptions } from "../shared/types";
+
+	export let value: null | FileData = null;
+	export let label: string;
+	export let root: string;
+	export let loop: boolean;
+	export let show_label = true;
+	export let show_download_button = false;
+	export let sources:
+		| ["microphone"]
+		| ["upload"]
+		| ["microphone", "upload"]
+		| ["upload", "microphone"] = ["microphone", "upload"];
+	export let pending = false;
+	export let streaming = false;
+	export let i18n: I18nFormatter;
+	export let waveform_settings: Record<string, any>;
+	export let trim_region_settings = {};
+	export let waveform_options: WaveformOptions = {};
+	export let dragging: boolean;
+	export let active_source: "microphone" | "upload";
+	export let handle_reset_value: () => void = () => {};
+	export let editable = true;
+	export let max_file_size: number | null = null;
+	export let upload: Client["upload"];
+	export let stream_handler: Client["stream"];
+	export let stream_every: number;
+	export let uploading = false;
+	export let recording = false;
+
+	let time_limit: number | null = null;
+	let stream_state: "open" | "waiting" | "closed" = "closed";
+
+	export const modify_stream: (state: "open" | "closed" | "waiting") => void = (
+		state: "open" | "closed" | "waiting"
+	) => {
+		if (state === "closed") {
+			time_limit = null;
+			stream_state = "closed";
+		} else if (state === "waiting") {
+			stream_state = "waiting";
+		} else {
+			stream_state = "open";
+		}
+	};
+
+	export const set_time_limit = (time: number): void => {
+		if (recording) time_limit = time;
+	};
+
+	$: dispatch("drag", dragging);
+
+	// TODO: make use of this
+	// export let type: "normal" | "numpy" = "normal";
+	let recorder: IMediaRecorder;
+	let mode = "";
+	let header: Uint8Array | undefined = undefined;
+	let pending_stream: Uint8Array[] = [];
+	let submit_pending_stream_on_pending_end = false;
+	let inited = false;
+
+	const NUM_HEADER_BYTES = 44;
+	let audio_chunks: Blob[] = [];
+	let module_promises: [
+		Promise<typeof import("extendable-media-recorder")>,
+		Promise<typeof import("extendable-media-recorder-wav-encoder")>
+	];
+
+	function get_modules(): void {
+		module_promises = [
+			import("extendable-media-recorder"),
+			import("extendable-media-recorder-wav-encoder")
+		];
+	}
+
+	const is_browser = typeof window !== "undefined";
+	if (is_browser && streaming) {
+		get_modules();
+	}
+
+	const dispatch = createEventDispatcher<{
+		change: FileData | null;
+		stream: FileData;
+		edit: never;
+		play: never;
+		pause: never;
+		stop: never;
+		end: never;
+		drag: boolean;
+		error: string;
+		upload: FileData;
+		clear: undefined;
+		start_recording: undefined;
+		pause_recording: undefined;
+		stop_recording: undefined;
+		close_stream: undefined;
+	}>();
+
+	const dispatch_blob = async (
+		blobs: Uint8Array[] | Blob[],
+		event: "stream" | "change" | "stop_recording"
+	): Promise<void> => {
+		let _audio_blob = new File(blobs, "audio.wav");
+		const val = await prepare_files([_audio_blob], event === "stream");
+		value = (
+			(await upload(val, root, undefined, max_file_size || undefined))?.filter(
+				Boolean
+			) as FileData[]
+		)[0];
+		dispatch(event, value);
+	};
+
+	onDestroy(() => {
+		if (streaming && recorder && recorder.state !== "inactive") {
+			recorder.stop();
+		}
+	});
+
+	async function prepare_audio(): Promise<void> {
+		let stream: MediaStream | null;
+
+		try {
+			stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+		} catch (err) {
+			if (!navigator.mediaDevices) {
+				dispatch("error", i18n("audio.no_device_support"));
+				return;
+			}
+			if (err instanceof DOMException && err.name == "NotAllowedError") {
+				dispatch("error", i18n("audio.allow_recording_access"));
+				return;
+			}
+			throw err;
+		}
+		if (stream == null) return;
+
+		if (streaming) {
+			const [{ MediaRecorder, register }, { connect }] =
+				await Promise.all(module_promises);
+			await register(await connect());
+			recorder = new MediaRecorder(stream, { mimeType: "audio/wav" });
+			recorder.addEventListener("dataavailable", handle_chunk);
+		} else {
+			recorder = new MediaRecorder(stream);
+			recorder.addEventListener("dataavailable", (event) => {
+				audio_chunks.push(event.data);
+			});
+		}
+		recorder.addEventListener("stop", async () => {
+			recording = false;
+			// recorder.stop();
+			await dispatch_blob(audio_chunks, "change");
+			await dispatch_blob(audio_chunks, "stop_recording");
+			audio_chunks = [];
+		});
+		inited = true;
+	}
+
+	async function handle_chunk(event: IBlobEvent): Promise<void> {
+		let buffer = await event.data.arrayBuffer();
+		let payload = new Uint8Array(buffer);
+		if (!header) {
+			header = new Uint8Array(buffer.slice(0, NUM_HEADER_BYTES));
+			payload = new Uint8Array(buffer.slice(NUM_HEADER_BYTES));
+		}
+		if (pending) {
+			pending_stream.push(payload);
+		} else {
+			let blobParts = [header].concat(pending_stream, [payload]);
+			if (!recording || stream_state === "waiting") return;
+			dispatch_blob(blobParts, "stream");
+			pending_stream = [];
+		}
+	}
+
+	$: if (submit_pending_stream_on_pending_end && pending === false) {
+		submit_pending_stream_on_pending_end = false;
+		if (header && pending_stream) {
+			let blobParts: Uint8Array[] = [header].concat(pending_stream);
+			pending_stream = [];
+			dispatch_blob(blobParts, "stream");
+		}
+	}
+
+	async function record(): Promise<void> {
+		recording = true;
+		dispatch("start_recording");
+		if (!inited) await prepare_audio();
+		header = undefined;
+		if (streaming) {
+			recorder.start(stream_every * 1000);
+		}
+	}
+
+	function clear(): void {
+		dispatch("change", null);
+		dispatch("clear");
+		mode = "";
+		value = null;
+	}
+
+	function handle_load({ detail }: { detail: FileData }): void {
+		value = detail;
+		dispatch("change", detail);
+		dispatch("upload", detail);
+	}
+
+	async function stop(): Promise<void> {
+		recording = false;
+
+		if (streaming) {
+			dispatch("close_stream");
+			dispatch("stop_recording");
+			recorder.stop();
+
+			if (pending) {
+				submit_pending_stream_on_pending_end = true;
+			}
+			dispatch_blob(audio_chunks, "stop_recording");
+			dispatch("clear");
+			mode = "";
+		}
+	}
+
+	$: if (!recording && recorder) stop();
+	$: if (recording && recorder) record();
+</script>
+
+<BlockLabel
+	{show_label}
+	Icon={Music}
+	float={active_source === "upload" && value === null}
+	label={label || i18n("audio.audio")}
+/>
+<div class="audio-container">
+	<StreamingBar {time_limit} />
+	{#if value === null || streaming}
+		{#if active_source === "microphone"}
+			<ModifyUpload {i18n} on:clear={clear} />
+			{#if streaming}
+				<StreamAudio
+					{record}
+					{recording}
+					{stop}
+					{i18n}
+					{waveform_settings}
+					{waveform_options}
+					waiting={stream_state === "waiting"}
+				/>
+			{:else}
+				<AudioRecorder
+					bind:mode
+					{i18n}
+					{editable}
+					{recording}
+					{dispatch_blob}
+					{waveform_settings}
+					{waveform_options}
+					{handle_reset_value}
+					on:start_recording
+					on:pause_recording
+					on:stop_recording
+				/>
+			{/if}
+		{:else if active_source === "upload"}
+			<!-- explicitly listed out audio mimetypes due to iOS bug not recognizing audio/* -->
+			<Upload
+				filetype="audio/aac,audio/midi,audio/mpeg,audio/ogg,audio/wav,audio/x-wav,audio/opus,audio/webm,audio/flac,audio/vnd.rn-realaudio,audio/x-ms-wma,audio/x-aiff,audio/amr,audio/*"
+				on:load={handle_load}
+				bind:dragging
+				bind:uploading
+				on:error={({ detail }) => dispatch("error", detail)}
+				{root}
+				{max_file_size}
+				{upload}
+				{stream_handler}
+			>
+				<slot />
+			</Upload>
+		{/if}
+	{:else}
+		<ModifyUpload
+			{i18n}
+			on:clear={clear}
+			on:edit={() => (mode = "edit")}
+			download={show_download_button ? value.url : null}
+		/>
+
+		<AudioPlayer
+			bind:mode
+			{value}
+			{label}
+			{i18n}
+			{dispatch_blob}
+			{waveform_settings}
+			{waveform_options}
+			{trim_region_settings}
+			{handle_reset_value}
+			{editable}
+			{loop}
+			interactive
+			on:stop
+			on:play
+			on:pause
+			on:edit
+		/>
+	{/if}
+	<SelectSource {sources} bind:active_source handle_clear={clear} />
+</div>
+
+<style>
+	.audio-container {
+		height: calc(var(--size-full) - var(--size-6));
+		display: flex;
+		flex-direction: column;
+		justify-content: space-between;
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/audio/package.json

@@ -0,0 +1,62 @@
+{
+	"name": "@gradio/audio",
+	"version": "0.14.2",
+	"description": "Gradio UI packages",
+	"type": "module",
+	"author": "",
+	"license": "ISC",
+	"private": false,
+	"dependencies": {
+		"@gradio/atoms": "workspace:^",
+		"@gradio/button": "workspace:^",
+		"@gradio/client": "workspace:^",
+		"@gradio/icons": "workspace:^",
+		"@gradio/statustracker": "workspace:^",
+		"@gradio/upload": "workspace:^",
+		"@gradio/utils": "workspace:^",
+		"@gradio/wasm": "workspace:^",
+		"@types/wavesurfer.js": "^6.0.10",
+		"extendable-media-recorder": "^9.0.0",
+		"extendable-media-recorder-wav-encoder": "^7.0.76",
+		"hls.js": "^1.5.13",
+		"resize-observer-polyfill": "^1.5.1",
+		"svelte-range-slider-pips": "^2.0.1",
+		"wavesurfer.js": "^7.4.2"
+	},
+	"devDependencies": {
+		"@gradio/preview": "workspace:^"
+	},
+	"main_changeset": true,
+	"main": "index.ts",
+	"exports": {
+		"./package.json": "./package.json",
+		".": {
+			"gradio": "./index.ts",
+			"svelte": "./dist/index.js",
+			"types": "./dist/index.d.ts"
+		},
+		"./example": {
+			"gradio": "./Example.svelte",
+			"svelte": "./dist/Example.svelte",
+			"types": "./dist/Example.svelte.d.ts"
+		},
+		"./shared": {
+			"gradio": "./shared/index.ts",
+			"svelte": "./dist/shared/index.js",
+			"types": "./dist/shared/index.d.ts"
+		},
+		"./base": {
+			"gradio": "./static/StaticAudio.svelte",
+			"svelte": "./dist/static/StaticAudio.svelte",
+			"types": "./dist/static/StaticAudio.svelte.d.ts"
+		}
+	},
+	"peerDependencies": {
+		"svelte": "^4.0.0"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "js/audio"
+	}
+}

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/audio/recorder/AudioRecorder.svelte

@@ -0,0 +1,287 @@
+<script lang="ts">
+	import { onMount } from "svelte";
+	import type { I18nFormatter } from "@gradio/utils";
+	import { createEventDispatcher } from "svelte";
+	import WaveSurfer from "wavesurfer.js";
+	import { skip_audio, process_audio } from "../shared/utils";
+	import WSRecord from "wavesurfer.js/dist/plugins/record.js";
+	import WaveformControls from "../shared/WaveformControls.svelte";
+	import WaveformRecordControls from "../shared/WaveformRecordControls.svelte";
+	import RecordPlugin from "wavesurfer.js/dist/plugins/record.js";
+	import type { WaveformOptions } from "../shared/types";
+	import { format_time } from "@gradio/utils";
+
+	export let mode: string;
+	export let i18n: I18nFormatter;
+	export let dispatch_blob: (
+		blobs: Uint8Array[] | Blob[],
+		event: "stream" | "change" | "stop_recording"
+	) => Promise<void> | undefined;
+	export let waveform_settings: Record<string, any>;
+	export let waveform_options: WaveformOptions = {
+		show_recording_waveform: true
+	};
+	export let handle_reset_value: () => void;
+	export let editable = true;
+	export let recording = false;
+
+	let micWaveform: WaveSurfer;
+	let recordingWaveform: WaveSurfer;
+	let playing = false;
+
+	let recordingContainer: HTMLDivElement;
+	let microphoneContainer: HTMLDivElement;
+
+	let record: WSRecord;
+	let recordedAudio: string | null = null;
+
+	// timestamps
+	let timeRef: HTMLTimeElement;
+	let durationRef: HTMLTimeElement;
+	let audio_duration: number;
+	let seconds = 0;
+	let interval: NodeJS.Timeout;
+	let timing = false;
+	// trimming
+	let trimDuration = 0;
+
+	const start_interval = (): void => {
+		clearInterval(interval);
+		interval = setInterval(() => {
+			seconds++;
+		}, 1000);
+	};
+
+	const dispatch = createEventDispatcher<{
+		start_recording: undefined;
+		pause_recording: undefined;
+		stop_recording: undefined;
+		stop: undefined;
+		play: undefined;
+		pause: undefined;
+		end: undefined;
+		edit: undefined;
+	}>();
+
+	function record_start_callback(): void {
+		start_interval();
+		timing = true;
+		dispatch("start_recording");
+		if (waveform_options.show_recording_waveform) {
+			let waveformCanvas = microphoneContainer;
+			if (waveformCanvas) waveformCanvas.style.display = "block";
+		}
+	}
+
+	async function record_end_callback(blob: Blob): Promise<void> {
+		seconds = 0;
+		timing = false;
+		clearInterval(interval);
+		try {
+			const array_buffer = await blob.arrayBuffer();
+			const context = new AudioContext({
+				sampleRate: waveform_settings.sampleRate
+			});
+			const audio_buffer = await context.decodeAudioData(array_buffer);
+
+			if (audio_buffer)
+				await process_audio(audio_buffer).then(async (audio: Uint8Array) => {
+					await dispatch_blob([audio], "change");
+					await dispatch_blob([audio], "stop_recording");
+				});
+		} catch (e) {
+			console.error(e);
+		}
+	}
+
+	$: record?.on("record-resume", () => {
+		start_interval();
+	});
+
+	$: recordingWaveform?.on("decode", (duration: any) => {
+		audio_duration = duration;
+		durationRef && (durationRef.textContent = format_time(duration));
+	});
+
+	$: recordingWaveform?.on(
+		"timeupdate",
+		(currentTime: any) =>
+			timeRef && (timeRef.textContent = format_time(currentTime))
+	);
+
+	$: recordingWaveform?.on("pause", () => {
+		dispatch("pause");
+		playing = false;
+	});
+
+	$: recordingWaveform?.on("play", () => {
+		dispatch("play");
+		playing = true;
+	});
+
+	$: recordingWaveform?.on("finish", () => {
+		dispatch("stop");
+		playing = false;
+	});
+
+	const create_mic_waveform = (): void => {
+		if (microphoneContainer) microphoneContainer.innerHTML = "";
+		if (micWaveform !== undefined) micWaveform.destroy();
+		if (!microphoneContainer) return;
+		micWaveform = WaveSurfer.create({
+			...waveform_settings,
+			normalize: false,
+			container: microphoneContainer
+		});
+
+		record = micWaveform.registerPlugin(RecordPlugin.create());
+		record.startMic();
+		record?.on("record-end", record_end_callback);
+		record?.on("record-start", record_start_callback);
+		record?.on("record-pause", () => {
+			dispatch("pause_recording");
+			clearInterval(interval);
+		});
+
+		record?.on("record-end", (blob) => {
+			recordedAudio = URL.createObjectURL(blob);
+
+			const microphone = microphoneContainer;
+			const recording = recordingContainer;
+
+			if (microphone) microphone.style.display = "none";
+			if (recording && recordedAudio) {
+				recording.innerHTML = "";
+				create_recording_waveform();
+			}
+		});
+	};
+
+	const create_recording_waveform = (): void => {
+		let recording = recordingContainer;
+		if (!recordedAudio || !recording) return;
+		recordingWaveform = WaveSurfer.create({
+			container: recording,
+			url: recordedAudio,
+			...waveform_settings
+		});
+	};
+
+	const handle_trim_audio = async (
+		start: number,
+		end: number
+	): Promise<void> => {
+		mode = "edit";
+		const decodedData = recordingWaveform.getDecodedData();
+		if (decodedData)
+			await process_audio(decodedData, start, end).then(
+				async (trimmedAudio: Uint8Array) => {
+					await dispatch_blob([trimmedAudio], "change");
+					await dispatch_blob([trimmedAudio], "stop_recording");
+					recordingWaveform.destroy();
+					create_recording_waveform();
+				}
+			);
+		dispatch("edit");
+	};
+
+	onMount(() => {
+		create_mic_waveform();
+
+		window.addEventListener("keydown", (e) => {
+			if (e.key === "ArrowRight") {
+				skip_audio(recordingWaveform, 0.1);
+			} else if (e.key === "ArrowLeft") {
+				skip_audio(recordingWaveform, -0.1);
+			}
+		});
+	});
+</script>
+
+<div class="component-wrapper">
+	<div
+		class="microphone"
+		bind:this={microphoneContainer}
+		data-testid="microphone-waveform"
+	/>
+	<div bind:this={recordingContainer} data-testid="recording-waveform" />
+
+	{#if (timing || recordedAudio) && waveform_options.show_recording_waveform}
+		<div class="timestamps">
+			<time bind:this={timeRef} class="time">0:00</time>
+			<div>
+				{#if mode === "edit" && trimDuration > 0}
+					<time class="trim-duration">{format_time(trimDuration)}</time>
+				{/if}
+				{#if timing}
+					<time class="duration">{format_time(seconds)}</time>
+				{:else}
+					<time bind:this={durationRef} class="duration">0:00</time>
+				{/if}
+			</div>
+		</div>
+	{/if}
+
+	{#if microphoneContainer && !recordedAudio}
+		<WaveformRecordControls
+			bind:record
+			{i18n}
+			{timing}
+			{recording}
+			show_recording_waveform={waveform_options.show_recording_waveform}
+			record_time={format_time(seconds)}
+		/>
+	{/if}
+
+	{#if recordingWaveform && recordedAudio}
+		<WaveformControls
+			bind:waveform={recordingWaveform}
+			container={recordingContainer}
+			{playing}
+			{audio_duration}
+			{i18n}
+			{editable}
+			interactive={true}
+			{handle_trim_audio}
+			bind:trimDuration
+			bind:mode
+			show_redo
+			{handle_reset_value}
+			{waveform_options}
+		/>
+	{/if}
+</div>
+
+<style>
+	.microphone {
+		width: 100%;
+		display: none;
+	}
+
+	.component-wrapper {
+		padding: var(--size-3);
+		width: 100%;
+	}
+
+	.timestamps {
+		display: flex;
+		justify-content: space-between;
+		align-items: center;
+		width: 100%;
+		padding: var(--size-1) 0;
+		margin: var(--spacing-md) 0;
+	}
+
+	.time {
+		color: var(--neutral-400);
+	}
+
+	.duration {
+		color: var(--neutral-400);
+	}
+
+	.trim-duration {
+		color: var(--color-accent);
+		margin-right: var(--spacing-sm);
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/audio/shared/VolumeLevels.svelte

@@ -0,0 +1,12 @@
+<script lang="ts">
+	import { VolumeMuted, VolumeHigh, VolumeLow } from "@gradio/icons";
+	export let currentVolume: number;
+</script>
+
+{#if currentVolume == 0}
+	<VolumeMuted />
+{:else if currentVolume < 0.5}
+	<VolumeLow />
+{:else if currentVolume >= 0.5}
+	<VolumeHigh />
+{/if}

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/audio/shared/WaveformRecordControls.svelte

@@ -0,0 +1,279 @@
+<script lang="ts">
+	import { Pause } from "@gradio/icons";
+	import type { I18nFormatter } from "@gradio/utils";
+	import RecordPlugin from "wavesurfer.js/dist/plugins/record.js";
+	import DeviceSelect from "./DeviceSelect.svelte";
+
+	export let record: RecordPlugin;
+	export let i18n: I18nFormatter;
+	export let recording = false;
+
+	let micDevices: MediaDeviceInfo[] = [];
+	let recordButton: HTMLButtonElement;
+	let pauseButton: HTMLButtonElement;
+	let resumeButton: HTMLButtonElement;
+	let stopButton: HTMLButtonElement;
+	let stopButtonPaused: HTMLButtonElement;
+	let recording_ongoing = false;
+
+	export let record_time: string;
+	export let show_recording_waveform: boolean | undefined;
+	export let timing = false;
+
+	$: record.on("record-start", () => {
+		record.startMic();
+
+		recordButton.style.display = "none";
+		stopButton.style.display = "flex";
+		pauseButton.style.display = "block";
+	});
+
+	$: record.on("record-end", () => {
+		if (record.isPaused()) {
+			record.resumeRecording();
+			record.stopRecording();
+		}
+		record.stopMic();
+
+		recordButton.style.display = "flex";
+		stopButton.style.display = "none";
+		pauseButton.style.display = "none";
+		recordButton.disabled = false;
+	});
+
+	$: record.on("record-pause", () => {
+		pauseButton.style.display = "none";
+		resumeButton.style.display = "block";
+		stopButton.style.display = "none";
+		stopButtonPaused.style.display = "flex";
+	});
+
+	$: record.on("record-resume", () => {
+		pauseButton.style.display = "block";
+		resumeButton.style.display = "none";
+		recordButton.style.display = "none";
+		stopButton.style.display = "flex";
+		stopButtonPaused.style.display = "none";
+	});
+
+	$: if (recording && !recording_ongoing) {
+		record.startRecording();
+		recording_ongoing = true;
+	} else {
+		record.stopRecording();
+		recording_ongoing = false;
+	}
+</script>
+
+<div class="controls">
+	<div class="wrapper">
+		<button
+			bind:this={recordButton}
+			class="record record-button"
+			on:click={() => record.startRecording()}>{i18n("audio.record")}</button
+		>
+
+		<button
+			bind:this={stopButton}
+			class="stop-button {record.isPaused() ? 'stop-button-paused' : ''}"
+			on:click={() => {
+				if (record.isPaused()) {
+					record.resumeRecording();
+					record.stopRecording();
+				}
+
+				record.stopRecording();
+			}}>{i18n("audio.stop")}</button
+		>
+
+		<button
+			bind:this={stopButtonPaused}
+			id="stop-paused"
+			class="stop-button-paused"
+			on:click={() => {
+				if (record.isPaused()) {
+					record.resumeRecording();
+					record.stopRecording();
+				}
+
+				record.stopRecording();
+			}}>{i18n("audio.stop")}</button
+		>
+
+		<button
+			aria-label="pause"
+			bind:this={pauseButton}
+			class="pause-button"
+			on:click={() => record.pauseRecording()}><Pause /></button
+		>
+		<button
+			bind:this={resumeButton}
+			class="resume-button"
+			on:click={() => record.resumeRecording()}>{i18n("audio.resume")}</button
+		>
+		{#if timing && !show_recording_waveform}
+			<time class="duration-button duration">{record_time}</time>
+		{/if}
+	</div>
+	<DeviceSelect bind:micDevices {i18n} />
+</div>
+
+<style>
+	.controls {
+		display: flex;
+		align-items: center;
+		justify-content: space-between;
+		flex-wrap: wrap;
+	}
+
+	.wrapper {
+		display: flex;
+		align-items: center;
+		flex-wrap: wrap;
+	}
+
+	.record {
+		margin-right: var(--spacing-md);
+	}
+
+	.stop-button-paused {
+		display: none;
+		height: var(--size-8);
+		width: var(--size-20);
+		background-color: var(--block-background-fill);
+		border-radius: var(--button-large-radius);
+		align-items: center;
+		border: 1px solid var(--block-border-color);
+		margin: var(--size-1) var(--size-1) 0 0;
+	}
+
+	.stop-button-paused::before {
+		content: "";
+		height: var(--size-4);
+		width: var(--size-4);
+		border-radius: var(--radius-full);
+		background: var(--primary-600);
+		margin: 0 var(--spacing-xl);
+	}
+	.stop-button::before {
+		content: "";
+		height: var(--size-4);
+		width: var(--size-4);
+		border-radius: var(--radius-full);
+		background: var(--primary-600);
+		margin: 0 var(--spacing-xl);
+		animation: scaling 1800ms infinite;
+	}
+
+	.stop-button {
+		display: none;
+		height: var(--size-8);
+		width: var(--size-20);
+		background-color: var(--block-background-fill);
+		border-radius: var(--button-large-radius);
+		align-items: center;
+		border: 1px solid var(--primary-600);
+		margin: var(--size-1) var(--size-1) 0 0;
+	}
+
+	.record-button::before {
+		content: "";
+		height: var(--size-4);
+		width: var(--size-4);
+		border-radius: var(--radius-full);
+		background: var(--primary-600);
+		margin: 0 var(--spacing-xl);
+	}
+
+	.record-button {
+		height: var(--size-8);
+		width: var(--size-24);
+		background-color: var(--block-background-fill);
+		border-radius: var(--button-large-radius);
+		display: flex;
+		align-items: center;
+		border: 1px solid var(--block-border-color);
+	}
+
+	.stop-button:disabled {
+		cursor: not-allowed;
+	}
+
+	.record-button:disabled {
+		cursor: not-allowed;
+		opacity: 0.5;
+	}
+
+	@keyframes scaling {
+		0% {
+			background-color: var(--primary-600);
+			scale: 1;
+		}
+		50% {
+			background-color: var(--primary-600);
+			scale: 1.2;
+		}
+		100% {
+			background-color: var(--primary-600);
+			scale: 1;
+		}
+	}
+
+	.pause-button {
+		display: none;
+		height: var(--size-8);
+		width: var(--size-20);
+		border: 1px solid var(--block-border-color);
+		border-radius: var(--button-large-radius);
+		padding: var(--spacing-md);
+		margin: var(--size-1) var(--size-1) 0 0;
+	}
+
+	.resume-button {
+		display: none;
+		height: var(--size-8);
+		width: var(--size-20);
+		border: 1px solid var(--block-border-color);
+		border-radius: var(--button-large-radius);
+		padding: var(--spacing-xl);
+		line-height: 1px;
+		font-size: var(--text-md);
+		margin: var(--size-1) var(--size-1) 0 0;
+	}
+
+	.duration {
+		display: flex;
+		height: var(--size-8);
+		width: var(--size-20);
+		border: 1px solid var(--block-border-color);
+		padding: var(--spacing-md);
+		align-items: center;
+		justify-content: center;
+		margin: var(--size-1) var(--size-1) 0 0;
+	}
+
+	:global(::part(region)) {
+		border-radius: var(--radius-md);
+		height: 98% !important;
+		border: 1px solid var(--trim-region-color);
+		background-color: unset;
+		border-width: 1px 3px;
+	}
+
+	:global(::part(region))::after {
+		content: "";
+		position: absolute;
+		top: 0;
+		left: 0;
+		width: 100%;
+		height: 100%;
+		background: var(--trim-region-color);
+		opacity: 0.2;
+		border-radius: var(--radius-md);
+	}
+
+	:global(::part(region-handle)) {
+		width: 5px !important;
+		border: none;
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/audio/streaming/StreamAudio.svelte

@@ -0,0 +1,205 @@
+<script lang="ts">
+	import { onMount } from "svelte";
+	import type { I18nFormatter } from "@gradio/utils";
+	import { Spinner } from "@gradio/icons";
+	import WaveSurfer from "wavesurfer.js";
+	import RecordPlugin from "wavesurfer.js/dist/plugins/record.js";
+	import type { WaveformOptions } from "../shared/types";
+	import DeviceSelect from "../shared/DeviceSelect.svelte";
+
+	export let recording = false;
+	export let paused_recording = false;
+	export let stop: () => void;
+	export let record: () => void;
+	export let i18n: I18nFormatter;
+	export let waveform_settings: Record<string, any>;
+	export let waveform_options: WaveformOptions = {
+		show_recording_waveform: true
+	};
+	export let waiting = false;
+
+	let micWaveform: WaveSurfer;
+	let waveformRecord: RecordPlugin;
+
+	let microphoneContainer: HTMLDivElement;
+
+	let micDevices: MediaDeviceInfo[] = [];
+
+	onMount(() => {
+		create_mic_waveform();
+	});
+
+	const create_mic_waveform = (): void => {
+		if (micWaveform !== undefined) micWaveform.destroy();
+		if (!microphoneContainer) return;
+		micWaveform = WaveSurfer.create({
+			...waveform_settings,
+			height: 100,
+			container: microphoneContainer
+		});
+
+		waveformRecord = micWaveform.registerPlugin(RecordPlugin.create());
+	};
+</script>
+
+<div class="mic-wrap">
+	{#if waveform_options.show_recording_waveform}
+		<div
+			bind:this={microphoneContainer}
+			style:display={recording ? "block" : "none"}
+		/>
+	{/if}
+	<div class="controls">
+		{#if recording && !waiting}
+			<button
+				class={paused_recording ? "stop-button-paused" : "stop-button"}
+				on:click={() => {
+					waveformRecord?.stopMic();
+					stop();
+				}}
+			>
+				<span class="record-icon">
+					<span class="pinger" />
+					<span class="dot" />
+				</span>
+				{paused_recording ? i18n("audio.pause") : i18n("audio.stop")}
+			</button>
+		{:else if recording && waiting}
+			<button
+				class="spinner-button"
+				on:click={() => {
+					stop();
+				}}
+			>
+				<div class="icon">
+					<Spinner />
+				</div>
+				{i18n("audio.waiting")}
+			</button>
+		{:else}
+			<button
+				class="record-button"
+				on:click={() => {
+					waveformRecord?.startMic();
+					record();
+				}}
+			>
+				<span class="record-icon">
+					<span class="dot" />
+				</span>
+				{i18n("audio.record")}
+			</button>
+		{/if}
+
+		<DeviceSelect bind:micDevices {i18n} />
+	</div>
+</div>
+
+<style>
+	.controls {
+		display: flex;
+		align-items: center;
+		justify-content: space-between;
+		flex-wrap: wrap;
+	}
+
+	.mic-wrap {
+		display: block;
+		align-items: center;
+		margin: var(--spacing-xl);
+	}
+
+	.icon {
+		width: var(--size-4);
+		height: var(--size-4);
+		fill: var(--primary-600);
+		stroke: var(--primary-600);
+	}
+
+	.stop-button-paused {
+		display: none;
+		height: var(--size-8);
+		width: var(--size-20);
+		background-color: var(--block-background-fill);
+		border-radius: var(--button-large-radius);
+		align-items: center;
+		border: 1px solid var(--block-border-color);
+		margin-right: 5px;
+	}
+
+	.stop-button-paused::before {
+		content: "";
+		height: var(--size-4);
+		width: var(--size-4);
+		border-radius: var(--radius-full);
+		background: var(--primary-600);
+		margin: 0 var(--spacing-xl);
+	}
+
+	.stop-button::before {
+		content: "";
+		height: var(--size-4);
+		width: var(--size-4);
+		border-radius: var(--radius-full);
+		background: var(--primary-600);
+		margin: 0 var(--spacing-xl);
+		animation: scaling 1800ms infinite;
+	}
+
+	.stop-button {
+		height: var(--size-8);
+		width: var(--size-20);
+		background-color: var(--block-background-fill);
+		border-radius: var(--button-large-radius);
+		align-items: center;
+		border: 1px solid var(--primary-600);
+		margin-right: 5px;
+		display: flex;
+	}
+
+	.spinner-button {
+		height: var(--size-8);
+		width: var(--size-24);
+		background-color: var(--block-background-fill);
+		border-radius: var(--radius-3xl);
+		align-items: center;
+		border: 1px solid var(--primary-600);
+		margin: 0 var(--spacing-xl);
+		display: flex;
+		justify-content: space-evenly;
+	}
+
+	.record-button::before {
+		content: "";
+		height: var(--size-4);
+		width: var(--size-4);
+		border-radius: var(--radius-full);
+		background: var(--primary-600);
+		margin: 0 var(--spacing-xl);
+	}
+
+	.record-button {
+		height: var(--size-8);
+		width: var(--size-24);
+		background-color: var(--block-background-fill);
+		border-radius: var(--button-large-radius);
+		display: flex;
+		align-items: center;
+		border: 1px solid var(--block-border-color);
+	}
+
+	@keyframes scaling {
+		0% {
+			background-color: var(--primary-600);
+			scale: 1;
+		}
+		50% {
+			background-color: var(--primary-600);
+			scale: 1.2;
+		}
+		100% {
+			background-color: var(--primary-600);
+			scale: 1;
+		}
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/button/package.json

@@ -0,0 +1,35 @@
+{
+	"name": "@gradio/button",
+	"version": "0.3.1",
+	"description": "Gradio UI packages",
+	"type": "module",
+	"author": "",
+	"license": "ISC",
+	"private": false,
+	"dependencies": {
+		"@gradio/client": "workspace:^",
+		"@gradio/upload": "workspace:^",
+		"@gradio/utils": "workspace:^"
+	},
+	"devDependencies": {
+		"@gradio/preview": "workspace:^"
+	},
+	"main": "./Index.svelte",
+	"main_changeset": true,
+	"exports": {
+		"./package.json": "./package.json",
+		".": {
+			"gradio": "./Index.svelte",
+			"svelte": "./dist/Index.svelte",
+			"types": "./dist/Index.svelte.d.ts"
+		}
+	},
+	"peerDependencies": {
+		"svelte": "^4.0.0"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "js/button"
+	}
+}

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/chatbot/Index.svelte

@@ -0,0 +1,178 @@
+<script context="module" lang="ts">
+	export { default as BaseChatBot } from "./shared/ChatBot.svelte";
+</script>
+
+<script lang="ts">
+	import type { Gradio, SelectData, LikeData } from "@gradio/utils";
+
+	import ChatBot from "./shared/ChatBot.svelte";
+	import type { UndoRetryData } from "./shared/utils";
+	import { Block, BlockLabel } from "@gradio/atoms";
+	import type { LoadingStatus } from "@gradio/statustracker";
+	import { Chat } from "@gradio/icons";
+	import type { FileData } from "@gradio/client";
+	import { StatusTracker } from "@gradio/statustracker";
+	import type {
+		Message,
+		ExampleMessage,
+		TupleFormat,
+		NormalisedMessage
+	} from "./types";
+
+	import { normalise_tuples, normalise_messages } from "./shared/utils";
+
+	export let elem_id = "";
+	export let elem_classes: string[] = [];
+	export let visible = true;
+	export let value: TupleFormat | Message[] = [];
+	export let scale: number | null = null;
+	export let min_width: number | undefined = undefined;
+	export let label: string;
+	export let show_label = true;
+	export let root: string;
+	export let _selectable = false;
+	export let likeable = false;
+	export let show_share_button = false;
+	export let rtl = false;
+	export let show_copy_button = true;
+	export let show_copy_all_button = false;
+	export let sanitize_html = true;
+	export let bubble_full_width = true;
+	export let layout: "bubble" | "panel" = "bubble";
+	export let type: "tuples" | "messages" = "tuples";
+	export let render_markdown = true;
+	export let line_breaks = true;
+	export let autoscroll = true;
+	export let _retryable = false;
+	export let _undoable = false;
+	export let latex_delimiters: {
+		left: string;
+		right: string;
+		display: boolean;
+	}[];
+	export let gradio: Gradio<{
+		change: typeof value;
+		select: SelectData;
+		share: ShareData;
+		error: string;
+		like: LikeData;
+		clear_status: LoadingStatus;
+		example_select: SelectData;
+		retry: UndoRetryData;
+		undo: UndoRetryData;
+		clear: null;
+	}>;
+
+	let _value: NormalisedMessage[] | null = [];
+
+	$: _value =
+		type === "tuples"
+			? normalise_tuples(value as TupleFormat, root)
+			: normalise_messages(value as Message[], root);
+
+	export let avatar_images: [FileData | null, FileData | null] = [null, null];
+	export let like_user_message = false;
+	export let loading_status: LoadingStatus | undefined = undefined;
+	export let height: number | string | undefined;
+	export let min_height: number | string | undefined;
+	export let max_height: number | string | undefined;
+	export let placeholder: string | null = null;
+	export let examples: ExampleMessage[] | null = null;
+	export let theme_mode: "system" | "light" | "dark";
+</script>
+
+<Block
+	{elem_id}
+	{elem_classes}
+	{visible}
+	padding={false}
+	{scale}
+	{min_width}
+	{height}
+	{min_height}
+	{max_height}
+	allow_overflow={true}
+	flex={true}
+	overflow_behavior="auto"
+>
+	{#if loading_status}
+		<StatusTracker
+			autoscroll={gradio.autoscroll}
+			i18n={gradio.i18n}
+			{...loading_status}
+			show_progress={loading_status.show_progress === "hidden"
+				? "hidden"
+				: "minimal"}
+			on:clear_status={() => gradio.dispatch("clear_status", loading_status)}
+		/>
+	{/if}
+	<div class="wrapper">
+		{#if show_label}
+			<BlockLabel
+				{show_label}
+				Icon={Chat}
+				float={true}
+				label={label || "Chatbot"}
+			/>
+		{/if}
+		<ChatBot
+			i18n={gradio.i18n}
+			selectable={_selectable}
+			{likeable}
+			{show_share_button}
+			{show_copy_all_button}
+			value={_value}
+			{latex_delimiters}
+			{render_markdown}
+			{theme_mode}
+			pending_message={loading_status?.status === "pending"}
+			generating={loading_status?.status === "generating"}
+			{rtl}
+			{show_copy_button}
+			{like_user_message}
+			on:change={() => gradio.dispatch("change", value)}
+			on:select={(e) => gradio.dispatch("select", e.detail)}
+			on:like={(e) => gradio.dispatch("like", e.detail)}
+			on:share={(e) => gradio.dispatch("share", e.detail)}
+			on:error={(e) => gradio.dispatch("error", e.detail)}
+			on:example_select={(e) => gradio.dispatch("example_select", e.detail)}
+			on:retry={(e) => gradio.dispatch("retry", e.detail)}
+			on:undo={(e) => gradio.dispatch("undo", e.detail)}
+			on:clear={() => {
+				value = [];
+				gradio.dispatch("clear");
+			}}
+			{avatar_images}
+			{sanitize_html}
+			{bubble_full_width}
+			{line_breaks}
+			{autoscroll}
+			{layout}
+			{placeholder}
+			{examples}
+			{_retryable}
+			{_undoable}
+			upload={(...args) => gradio.client.upload(...args)}
+			_fetch={(...args) => gradio.client.fetch(...args)}
+			load_component={gradio.load_component}
+			msg_format={type}
+			root={gradio.root}
+		/>
+	</div>
+</Block>
+
+<style>
+	.wrapper {
+		display: flex;
+		position: relative;
+		flex-direction: column;
+		align-items: start;
+		width: 100%;
+		height: 100%;
+		flex-grow: 1;
+	}
+
+	:global(.progress-text) {
+		right: auto;
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/chatbot/package.json

@@ -0,0 +1,50 @@
+{
+	"name": "@gradio/chatbot",
+	"version": "0.15.0",
+	"description": "Gradio UI packages",
+	"type": "module",
+	"author": "",
+	"license": "ISC",
+	"private": false,
+	"dependencies": {
+		"@gradio/atoms": "workspace:^",
+		"@gradio/client": "workspace:^",
+		"@gradio/gallery": "workspace:^",
+		"@gradio/icons": "workspace:^",
+		"@gradio/markdown": "workspace:^",
+		"@gradio/plot": "workspace:^",
+		"@gradio/statustracker": "workspace:^",
+		"@gradio/theme": "workspace:^",
+		"@gradio/upload": "workspace:^",
+		"@gradio/utils": "workspace:^",
+		"@gradio/wasm": "workspace:^",
+		"@types/dompurify": "^3.0.2",
+		"@types/katex": "^0.16.0",
+		"@types/prismjs": "1.26.4",
+		"dequal": "^2.0.2"
+	},
+	"devDependencies": {
+		"@gradio/audio": "workspace:^",
+		"@gradio/image": "workspace:^",
+		"@gradio/preview": "workspace:^",
+		"@gradio/video": "workspace:^"
+	},
+	"main_changeset": true,
+	"main": "./Index.svelte",
+	"exports": {
+		"./package.json": "./package.json",
+		".": {
+			"gradio": "./Index.svelte",
+			"svelte": "./dist/Index.svelte",
+			"types": "./dist/Index.svelte.d.ts"
+		}
+	},
+	"peerDependencies": {
+		"svelte": "^4.0.0"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "js/chatbot"
+	}
+}

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/chatbot/shared/ChatBot.svelte

@@ -0,0 +1,598 @@
+<script lang="ts">
+	import {
+		format_chat_for_sharing,
+		type UndoRetryData,
+		is_last_bot_message,
+		group_messages,
+		load_components,
+		get_components_from_messages
+	} from "./utils";
+	import type { NormalisedMessage } from "../types";
+	import { copy } from "@gradio/utils";
+	import Message from "./Message.svelte";
+
+	import { dequal } from "dequal/lite";
+	import {
+		afterUpdate,
+		createEventDispatcher,
+		type SvelteComponent,
+		type ComponentType,
+		tick,
+		onMount
+	} from "svelte";
+	import { Image } from "@gradio/image/shared";
+
+	import { Clear, Trash, Community, ScrollDownArrow } from "@gradio/icons";
+	import { IconButtonWrapper, IconButton } from "@gradio/atoms";
+	import type { SelectData, LikeData } from "@gradio/utils";
+	import type { ExampleMessage } from "../types";
+	import { MarkdownCode as Markdown } from "@gradio/markdown";
+	import type { FileData, Client } from "@gradio/client";
+	import type { I18nFormatter } from "js/core/src/gradio_helper";
+	import Pending from "./Pending.svelte";
+	import { ShareError } from "@gradio/utils";
+	import { Gradio } from "@gradio/utils";
+
+	export let value: NormalisedMessage[] | null = [];
+	let old_value: NormalisedMessage[] | null = null;
+
+	import CopyAll from "./CopyAll.svelte";
+
+	export let _fetch: typeof fetch;
+	export let load_component: Gradio["load_component"];
+
+	let _components: Record<string, ComponentType<SvelteComponent>> = {};
+
+	async function update_components(): Promise<void> {
+		_components = await load_components(
+			get_components_from_messages(value),
+			_components,
+			load_component
+		);
+	}
+
+	$: value, update_components();
+
+	export let latex_delimiters: {
+		left: string;
+		right: string;
+		display: boolean;
+	}[];
+	export let pending_message = false;
+	export let generating = false;
+	export let selectable = false;
+	export let likeable = false;
+	export let show_share_button = false;
+	export let show_copy_all_button = false;
+	export let rtl = false;
+	export let show_copy_button = false;
+	export let avatar_images: [FileData | null, FileData | null] = [null, null];
+	export let sanitize_html = true;
+	export let bubble_full_width = true;
+	export let render_markdown = true;
+	export let line_breaks = true;
+	export let autoscroll = true;
+	export let theme_mode: "system" | "light" | "dark";
+	export let i18n: I18nFormatter;
+	export let layout: "bubble" | "panel" = "bubble";
+	export let placeholder: string | null = null;
+	export let upload: Client["upload"];
+	export let msg_format: "tuples" | "messages" = "tuples";
+	export let examples: ExampleMessage[] | null = null;
+	export let _retryable = false;
+	export let _undoable = false;
+	export let like_user_message = false;
+	export let root: string;
+
+	let target: HTMLElement | null = null;
+
+	onMount(() => {
+		target = document.querySelector("div.gradio-container");
+	});
+
+	let div: HTMLDivElement;
+
+	let show_scroll_button = false;
+
+	const dispatch = createEventDispatcher<{
+		change: undefined;
+		select: SelectData;
+		like: LikeData;
+		undo: UndoRetryData;
+		retry: UndoRetryData;
+		clear: undefined;
+		share: any;
+		error: string;
+		example_select: SelectData;
+	}>();
+
+	function is_at_bottom(): boolean {
+		return div && div.offsetHeight + div.scrollTop > div.scrollHeight - 100;
+	}
+
+	function scroll_to_bottom(): void {
+		if (!div) return;
+		div.scrollTo(0, div.scrollHeight);
+		show_scroll_button = false;
+	}
+
+	let scroll_after_component_load = false;
+	function on_child_component_load(): void {
+		if (scroll_after_component_load) {
+			scroll_to_bottom();
+			scroll_after_component_load = false;
+		}
+	}
+
+	async function scroll_on_value_update(): Promise<void> {
+		if (!autoscroll) return;
+
+		if (is_at_bottom()) {
+			// Child components may be loaded asynchronously,
+			// so trigger the scroll again after they load.
+			scroll_after_component_load = true;
+
+			await tick(); // Wait for the DOM to update so that the scrollHeight is correct
+			scroll_to_bottom();
+		} else {
+			show_scroll_button = true;
+		}
+	}
+	onMount(() => {
+		scroll_on_value_update();
+	});
+	$: if (value || pending_message || _components) {
+		scroll_on_value_update();
+	}
+
+	onMount(() => {
+		function handle_scroll(): void {
+			if (is_at_bottom()) {
+				show_scroll_button = false;
+			} else {
+				scroll_after_component_load = false;
+			}
+		}
+
+		div?.addEventListener("scroll", handle_scroll);
+		return () => {
+			div?.removeEventListener("scroll", handle_scroll);
+		};
+	});
+
+	let image_preview_source: string;
+	let image_preview_source_alt: string;
+	let is_image_preview_open = false;
+
+	afterUpdate(() => {
+		if (!div) return;
+		div.querySelectorAll("img").forEach((n) => {
+			n.addEventListener("click", (e) => {
+				const target = e.target as HTMLImageElement;
+				if (target) {
+					image_preview_source = target.src;
+					image_preview_source_alt = target.alt;
+					is_image_preview_open = true;
+				}
+			});
+		});
+	});
+
+	$: {
+		if (!dequal(value, old_value)) {
+			old_value = value;
+			dispatch("change");
+		}
+	}
+
+	$: groupedMessages = value && group_messages(value, msg_format);
+
+	function handle_example_select(i: number, example: ExampleMessage): void {
+		dispatch("example_select", {
+			index: i,
+			value: { text: example.text, files: example.files }
+		});
+	}
+
+	function handle_like(
+		i: number,
+		message: NormalisedMessage,
+		selected: string | null
+	): void {
+		if (selected === "undo" || selected === "retry") {
+			const val_ = value as NormalisedMessage[];
+			// iterate through messages until we find the last user message
+			// the index of this message is where the user needs to edit the chat history
+			let last_index = val_.length - 1;
+			while (val_[last_index].role === "assistant") {
+				last_index--;
+			}
+			dispatch(selected, {
+				index: val_[last_index].index,
+				value: val_[last_index].content
+			});
+			return;
+		}
+
+		if (msg_format === "tuples") {
+			dispatch("like", {
+				index: message.index,
+				value: message.content,
+				liked: selected === "like"
+			});
+		} else {
+			if (!groupedMessages) return;
+
+			const message_group = groupedMessages[i];
+			const [first, last] = [
+				message_group[0],
+				message_group[message_group.length - 1]
+			];
+
+			dispatch("like", {
+				index: [first.index, last.index] as [number, number],
+				value: message_group.map((m) => m.content),
+				liked: selected === "like"
+			});
+		}
+	}
+</script>
+
+{#if value !== null && value.length > 0}
+	<IconButtonWrapper>
+		{#if show_share_button}
+			<IconButton
+				Icon={Community}
+				on:click={async () => {
+					try {
+						// @ts-ignore
+						const formatted = await format_chat_for_sharing(value);
+						dispatch("share", {
+							description: formatted
+						});
+					} catch (e) {
+						console.error(e);
+						let message = e instanceof ShareError ? e.message : "Share failed.";
+						dispatch("error", message);
+					}
+				}}
+			>
+				<Community />
+			</IconButton>
+		{/if}
+		<IconButton Icon={Trash} on:click={() => dispatch("clear")} label={"Clear"}
+		></IconButton>
+		{#if show_copy_all_button}
+			<CopyAll {value} />
+		{/if}
+	</IconButtonWrapper>
+{/if}
+
+<div
+	class={layout === "bubble" ? "bubble-wrap" : "panel-wrap"}
+	bind:this={div}
+	role="log"
+	aria-label="chatbot conversation"
+	aria-live="polite"
+>
+	{#if value !== null && value.length > 0 && groupedMessages !== null}
+		<div class="message-wrap" use:copy>
+			{#each groupedMessages as messages, i}
+				{@const role = messages[0].role === "user" ? "user" : "bot"}
+				{@const avatar_img = avatar_images[role === "user" ? 0 : 1]}
+				{@const opposite_avatar_img = avatar_images[role === "user" ? 0 : 1]}
+				{#if is_image_preview_open}
+					<div class="image-preview">
+						<img src={image_preview_source} alt={image_preview_source_alt} />
+						<button
+							class="image-preview-close-button"
+							on:click={() => {
+								is_image_preview_open = false;
+							}}><Clear /></button
+						>
+					</div>
+				{/if}
+				<Message
+					{messages}
+					{opposite_avatar_img}
+					{avatar_img}
+					{role}
+					{layout}
+					{dispatch}
+					{i18n}
+					{_fetch}
+					{line_breaks}
+					{theme_mode}
+					{target}
+					{root}
+					{upload}
+					{selectable}
+					{sanitize_html}
+					{bubble_full_width}
+					{render_markdown}
+					{rtl}
+					{i}
+					{value}
+					{latex_delimiters}
+					{_components}
+					{generating}
+					{msg_format}
+					show_like={role === "user" ? likeable && like_user_message : likeable}
+					show_retry={_retryable && is_last_bot_message(messages, value)}
+					show_undo={_undoable && is_last_bot_message(messages, value)}
+					{show_copy_button}
+					handle_action={(selected) => handle_like(i, messages[0], selected)}
+					{scroll}
+				/>
+			{/each}
+			{#if pending_message}
+				<Pending {layout} />
+			{/if}
+		</div>
+	{:else}
+		<div class="placeholder-content">
+			{#if placeholder !== null}
+				<div class="placeholder">
+					<Markdown message={placeholder} {latex_delimiters} {root} />
+				</div>
+			{/if}
+			{#if examples !== null}
+				<div class="examples">
+					{#each examples as example, i}
+						<button
+							class="example"
+							on:click={() => handle_example_select(i, example)}
+						>
+							{#if example.icon !== undefined}
+								<div class="example-icon-container">
+									<Image
+										class="example-icon"
+										src={example.icon.url}
+										alt="example-icon"
+									/>
+								</div>
+							{/if}
+							{#if example.display_text !== undefined}
+								<span class="example-display-text">{example.display_text}</span>
+							{:else}
+								<span class="example-text">{example.text}</span>
+							{/if}
+							{#if example.files !== undefined && example.files.length > 1}
+								<span class="example-file"
+									><em>{example.files.length} Files</em></span
+								>
+							{:else if example.files !== undefined && example.files[0] !== undefined && example.files[0].mime_type?.includes("image")}
+								<div class="example-image-container">
+									<Image
+										class="example-image"
+										src={example.files[0].url}
+										alt="example-image"
+									/>
+								</div>
+							{:else if example.files !== undefined && example.files[0] !== undefined}
+								<span class="example-file"
+									><em>{example.files[0].orig_name}</em></span
+								>
+							{/if}
+						</button>
+					{/each}
+				</div>
+			{/if}
+		</div>
+	{/if}
+</div>
+
+{#if show_scroll_button}
+	<div class="scroll-down-button-container">
+		<IconButton
+			Icon={ScrollDownArrow}
+			label="Scroll down"
+			size="large"
+			on:click={scroll_to_bottom}
+		/>
+	</div>
+{/if}
+
+<style>
+	.placeholder-content {
+		display: flex;
+		flex-direction: column;
+		height: 100%;
+	}
+
+	.placeholder {
+		align-items: center;
+		display: flex;
+		justify-content: center;
+		height: 100%;
+		flex-grow: 1;
+	}
+
+	.examples :global(img) {
+		pointer-events: none;
+	}
+
+	.examples {
+		margin: auto;
+		padding: var(--spacing-xxl);
+		display: grid;
+		grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+		gap: var(--spacing-xxl);
+		max-width: calc(min(4 * 200px + 5 * var(--spacing-xxl), 100%));
+	}
+
+	.example {
+		display: flex;
+		flex-direction: column;
+		align-items: center;
+		padding: var(--spacing-xl);
+		border: 0.05px solid var(--border-color-primary);
+		border-radius: var(--radius-xl);
+		background-color: var(--background-fill-secondary);
+		cursor: pointer;
+		transition: var(--button-transition);
+		max-width: var(--size-56);
+		width: 100%;
+		justify-content: center;
+	}
+
+	.example:hover {
+		background-color: var(--color-accent-soft);
+		border-color: var(--border-color-accent);
+	}
+
+	.example-icon-container {
+		display: flex;
+		align-self: flex-start;
+		margin-left: var(--spacing-md);
+		width: var(--size-6);
+		height: var(--size-6);
+	}
+
+	.example-display-text,
+	.example-text,
+	.example-file {
+		font-size: var(--text-md);
+		width: 100%;
+		text-align: center;
+		overflow: hidden;
+		text-overflow: ellipsis;
+	}
+
+	.example-display-text,
+	.example-file {
+		margin-top: var(--spacing-md);
+	}
+
+	.example-image-container {
+		flex-grow: 1;
+		display: flex;
+		justify-content: center;
+		align-items: center;
+		margin-top: var(--spacing-xl);
+	}
+
+	.example-image-container :global(img) {
+		max-height: 100%;
+		max-width: 100%;
+		height: var(--size-32);
+		width: 100%;
+		object-fit: cover;
+		border-radius: var(--radius-xl);
+	}
+
+	.panel-wrap {
+		width: 100%;
+		overflow-y: auto;
+	}
+
+	.bubble-wrap {
+		width: 100%;
+		overflow-y: auto;
+		height: 100%;
+		padding-top: var(--spacing-xxl);
+	}
+
+	@media (prefers-color-scheme: dark) {
+		.bubble-wrap {
+			background: var(--background-fill-secondary);
+		}
+	}
+
+	.message-wrap {
+		display: flex;
+		flex-direction: column;
+		justify-content: space-between;
+		margin-bottom: var(--spacing-xxl);
+	}
+
+	.message-wrap :global(.prose.chatbot.md) {
+		opacity: 0.8;
+		overflow-wrap: break-word;
+	}
+
+	.message-wrap :global(.message-row .md img) {
+		border-radius: var(--radius-xl);
+		margin: var(--size-2);
+		width: 400px;
+		max-width: 30vw;
+		max-height: 30vw;
+	}
+
+	/* link styles */
+	.message-wrap :global(.message a) {
+		color: var(--color-text-link);
+		text-decoration: underline;
+	}
+
+	/* table styles */
+	.message-wrap :global(.bot table),
+	.message-wrap :global(.bot tr),
+	.message-wrap :global(.bot td),
+	.message-wrap :global(.bot th) {
+		border: 1px solid var(--border-color-primary);
+	}
+
+	.message-wrap :global(.user table),
+	.message-wrap :global(.user tr),
+	.message-wrap :global(.user td),
+	.message-wrap :global(.user th) {
+		border: 1px solid var(--border-color-accent);
+	}
+
+	/* KaTeX */
+	.message-wrap :global(span.katex) {
+		font-size: var(--text-lg);
+		direction: ltr;
+	}
+
+	.message-wrap :global(span.katex-display) {
+		margin-top: 0;
+	}
+
+	.message-wrap :global(pre) {
+		position: relative;
+	}
+
+	.message-wrap :global(.grid-wrap) {
+		max-height: 80% !important;
+		max-width: 600px;
+		object-fit: contain;
+	}
+
+	.message-wrap > div :global(p:not(:first-child)) {
+		margin-top: var(--spacing-xxl);
+	}
+
+	.message-wrap {
+		display: flex;
+		flex-direction: column;
+		justify-content: space-between;
+		margin-bottom: var(--spacing-xxl);
+	}
+
+	.panel-wrap :global(.message-row:first-child) {
+		padding-top: calc(var(--spacing-xxl) * 2);
+	}
+
+	.scroll-down-button-container {
+		position: absolute;
+		bottom: 10px;
+		left: 50%;
+		transform: translateX(-50%);
+		z-index: var(--layer-top);
+	}
+	.scroll-down-button-container :global(button) {
+		border-radius: 50%;
+		box-shadow: var(--shadow-drop);
+		transition:
+			box-shadow 0.2s ease-in-out,
+			transform 0.2s ease-in-out;
+	}
+	.scroll-down-button-container :global(button:hover) {
+		box-shadow:
+			var(--shadow-drop),
+			0 2px 2px rgba(0, 0, 0, 0.05);
+		transform: translateY(-2px);
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/chatbot/shared/CopyAll.svelte

@@ -0,0 +1,53 @@
+<script lang="ts">
+	import { onDestroy } from "svelte";
+	import { Copy, Check } from "@gradio/icons";
+	import type { NormalisedMessage } from "../types";
+	import { IconButton } from "@gradio/atoms";
+
+	let copied = false;
+	export let value: NormalisedMessage[] | null;
+
+	let timer: NodeJS.Timeout;
+
+	function copy_feedback(): void {
+		copied = true;
+		if (timer) clearTimeout(timer);
+		timer = setTimeout(() => {
+			copied = false;
+		}, 1000);
+	}
+
+	const copy_conversation = (): void => {
+		if (value) {
+			const conversation_value = value
+				.map((message) => {
+					if (message.type === "text") {
+						return `${message.role}: ${message.content}`;
+					}
+					return `${message.role}: ${message.content.value.url}`;
+				})
+				.join("\n\n");
+
+			navigator.clipboard.writeText(conversation_value).catch((err) => {
+				console.error("Failed to copy conversation: ", err);
+			});
+		}
+	};
+
+	async function handle_copy(): Promise<void> {
+		if ("clipboard" in navigator) {
+			copy_conversation();
+			copy_feedback();
+		}
+	}
+
+	onDestroy(() => {
+		if (timer) clearTimeout(timer);
+	});
+</script>
+
+<IconButton
+	Icon={copied ? Check : Copy}
+	on:click={handle_copy}
+	label={copied ? "Copied conversation" : "Copy conversation"}
+></IconButton>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/chatbot/shared/Download.svelte

@@ -0,0 +1,16 @@
+<svg
+	width="16"
+	height="16"
+	viewBox="0 0 12 12"
+	fill="none"
+	xmlns="http://www.w3.org/2000/svg"
+>
+	<path
+		d="M6.27701 8.253C6.24187 8.29143 6.19912 8.32212 6.15147 8.34311C6.10383 8.36411 6.05233 8.37495 6.00026 8.37495C5.94819 8.37495 5.89669 8.36411 5.84905 8.34311C5.8014 8.32212 5.75865 8.29143 5.72351 8.253L3.72351 6.0655C3.65798 5.99185 3.62408 5.89536 3.62916 5.79691C3.63424 5.69846 3.67788 5.60596 3.75064 5.53945C3.8234 5.47293 3.91943 5.43774 4.01794 5.44149C4.11645 5.44525 4.20952 5.48764 4.27701 5.5595L5.62501 7.0345V1.5C5.62501 1.40054 5.66452 1.30516 5.73485 1.23483C5.80517 1.16451 5.90055 1.125 6.00001 1.125C6.09947 1.125 6.19485 1.16451 6.26517 1.23483C6.3355 1.30516 6.37501 1.40054 6.37501 1.5V7.034L7.72351 5.559C7.79068 5.4856 7.88425 5.44189 7.98364 5.43748C8.08304 5.43308 8.18011 5.46833 8.25351 5.5355C8.32691 5.60267 8.37062 5.69624 8.37503 5.79563C8.37943 5.89503 8.34418 5.9921 8.27701 6.0655L6.27701 8.253Z"
+		fill="currentColor"
+	/>
+	<path
+		d="M1.875 7.39258C1.875 7.29312 1.83549 7.19774 1.76517 7.12741C1.69484 7.05709 1.59946 7.01758 1.5 7.01758C1.40054 7.01758 1.30516 7.05709 1.23483 7.12741C1.16451 7.19774 1.125 7.29312 1.125 7.39258V7.42008C1.125 8.10358 1.125 8.65508 1.1835 9.08858C1.2435 9.53858 1.3735 9.91758 1.674 10.2186C1.975 10.5196 2.354 10.6486 2.804 10.7096C3.2375 10.7676 3.789 10.7676 4.4725 10.7676H7.5275C8.211 10.7676 8.7625 10.7676 9.196 10.7096C9.646 10.6486 10.025 10.5196 10.326 10.2186C10.627 9.91758 10.756 9.53858 10.817 9.08858C10.875 8.65508 10.875 8.10358 10.875 7.42008V7.39258C10.875 7.29312 10.8355 7.19774 10.7652 7.12741C10.6948 7.05709 10.5995 7.01758 10.5 7.01758C10.4005 7.01758 10.3052 7.05709 10.2348 7.12741C10.1645 7.19774 10.125 7.29312 10.125 7.39258C10.125 8.11008 10.124 8.61058 10.0735 8.98858C10.024 9.35558 9.9335 9.54958 9.7955 9.68808C9.657 9.82658 9.463 9.91658 9.0955 9.96608C8.718 10.0166 8.2175 10.0176 7.5 10.0176H4.5C3.7825 10.0176 3.2815 10.0166 2.904 9.96608C2.537 9.91658 2.343 9.82608 2.2045 9.68808C2.066 9.54958 1.976 9.35558 1.9265 8.98808C1.876 8.61058 1.875 8.11008 1.875 7.39258Z"
+		fill="currentColor"
+	/>
+</svg>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/chatbot/shared/MessageBox.svelte

@@ -0,0 +1,61 @@
+<script lang="ts">
+	export let expanded = false;
+	export let title: string;
+
+	function toggleExpanded(): void {
+		expanded = !expanded;
+	}
+</script>
+
+<button class="box" on:click={toggleExpanded}>
+	<div class="title">
+		<span class="title-text">{title}</span>
+		<span
+			style:transform={expanded ? "rotate(0)" : "rotate(90deg)"}
+			class="arrow"
+		>
+			▼
+		</span>
+	</div>
+	{#if expanded}
+		<div class="content">
+			<slot></slot>
+		</div>
+	{/if}
+</button>
+
+<style>
+	.box {
+		border-radius: 4px;
+		cursor: pointer;
+		max-width: max-content;
+		background: var(--color-accent-soft);
+		border: 1px solid var(--border-color-accent-subdued);
+		font-size: 0.8em;
+	}
+
+	.title {
+		display: flex;
+		align-items: center;
+		padding: 3px 6px;
+		color: var(--body-text-color);
+		opacity: 0.8;
+	}
+
+	.content {
+		padding: 4px 8px;
+	}
+
+	.content :global(*) {
+		font-size: 0.8em;
+	}
+
+	.title-text {
+		padding-right: var(--spacing-lg);
+	}
+
+	.arrow {
+		margin-left: auto;
+		opacity: 0.8;
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/chatbot/shared/Pending.svelte

@@ -0,0 +1,60 @@
+<script lang="ts">
+	export let layout = "bubble";
+</script>
+
+<div
+	class="message pending"
+	role="status"
+	aria-label="Loading response"
+	aria-live="polite"
+	style:border-radius={layout === "bubble" ? "var(--radius-xxl)" : "none"}
+>
+	<span class="sr-only">Loading content</span>
+	<div class="dot-flashing" />
+	&nbsp;
+	<div class="dot-flashing" />
+	&nbsp;
+	<div class="dot-flashing" />
+</div>
+
+<style>
+	.pending {
+		background: var(--color-accent-soft);
+		display: flex;
+		flex-direction: row;
+		justify-content: center;
+		align-items: center;
+		align-self: center;
+		gap: 2px;
+		width: 100%;
+		height: var(--size-16);
+	}
+	.dot-flashing {
+		animation: flash 1s infinite ease-in-out;
+		border-radius: 5px;
+		background-color: var(--body-text-color);
+		width: 7px;
+		height: 7px;
+		color: var(--body-text-color);
+	}
+	@keyframes flash {
+		0%,
+		100% {
+			opacity: 0;
+		}
+		50% {
+			opacity: 1;
+		}
+	}
+
+	.dot-flashing:nth-child(1) {
+		animation-delay: 0s;
+	}
+
+	.dot-flashing:nth-child(2) {
+		animation-delay: 0.33s;
+	}
+	.dot-flashing:nth-child(3) {
+		animation-delay: 0.66s;
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/chatbot/shared/ThumbDownActive.svelte

@@ -0,0 +1,12 @@
+<svg
+	width="100%"
+	height="100%"
+	viewBox="0 0 12 12"
+	fill="none"
+	xmlns="http://www.w3.org/2000/svg"
+>
+	<path
+		d="M11.25 6.61523H9.375V1.36523H11.25V6.61523ZM3.375 1.36523H8.625V6.91636L7.48425 8.62748L7.16737 10.8464C7.14108 11.0248 7.05166 11.1879 6.91535 11.3061C6.77904 11.4242 6.60488 11.4896 6.4245 11.4902H6.375C6.07672 11.4899 5.79075 11.3713 5.57983 11.1604C5.36892 10.9495 5.2503 10.6635 5.25 10.3652V8.11523H2.25C1.85233 8.11474 1.47109 7.95654 1.18989 7.67535C0.908691 7.39415 0.750496 7.01291 0.75 6.61523V3.99023C0.750992 3.29435 1.02787 2.62724 1.51994 2.13517C2.01201 1.64311 2.67911 1.36623 3.375 1.36523Z"
+		fill="currentColor"
+	/>
+</svg>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/chatbot/shared/ThumbUpDefault.svelte

@@ -0,0 +1,12 @@
+<svg
+	width="100%"
+	height="100%"
+	viewBox="0 0 12 12"
+	fill="none"
+	xmlns="http://www.w3.org/2000/svg"
+>
+	<path
+		d="M9.75 4.74023H7.5V2.49023C7.4997 2.19196 7.38108 1.90598 7.17017 1.69507C6.95925 1.48415 6.67328 1.36553 6.375 1.36523H5.57512C5.39481 1.366 5.22074 1.43138 5.08451 1.54952C4.94828 1.66766 4.85891 1.83072 4.83262 2.00911L4.51575 4.22798L3.17438 6.24023H0.75V11.4902H8.625C9.32089 11.4892 9.98799 11.2124 10.4801 10.7203C10.9721 10.2282 11.249 9.56112 11.25 8.86523V6.24023C11.2495 5.84256 11.0913 5.46132 10.8101 5.18012C10.5289 4.89893 10.1477 4.74073 9.75 4.74023ZM3 10.7402H1.5V6.99023H3V10.7402ZM10.5 8.86523C10.4994 9.36233 10.3017 9.8389 9.95017 10.1904C9.59867 10.5419 9.1221 10.7396 8.625 10.7402H3.75V6.72886L5.23425 4.50248L5.5755 2.11523H6.375C6.47446 2.11523 6.56984 2.15474 6.64017 2.22507C6.71049 2.2954 6.75 2.39078 6.75 2.49023V5.49023H9.75C9.94882 5.49053 10.1394 5.56965 10.28 5.71023C10.4206 5.85082 10.4997 6.04141 10.5 6.24023V8.86523Z"
+		fill="currentColor"
+	/>
+</svg>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/chatbot/shared/autorender.d.ts

@@ -0,0 +1 @@
+declare module "katex/dist/contrib/auto-render.js";

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/chatbot/types.ts

@@ -0,0 +1,49 @@
+import type { FileData } from "@gradio/client";
+
+export type MessageRole = "system" | "user" | "assistant";
+
+export interface Metadata {
+	title: string | null;
+}
+
+export interface ComponentData {
+	component: string;
+	constructor_args: any;
+	props: any;
+	value: any;
+	alt_text: string | null;
+}
+
+export interface Message {
+	role: MessageRole;
+	metadata: Metadata;
+	content: string | FileData | ComponentData;
+	index: number | [number, number];
+}
+
+export interface TextMessage extends Message {
+	type: "text";
+	content: string;
+}
+
+export interface ComponentMessage extends Message {
+	type: "component";
+	content: ComponentData;
+}
+
+export interface ExampleMessage {
+	icon?: FileData;
+	display_text?: string;
+	text: string;
+	files?: FileData[];
+}
+
+export type message_data =
+	| string
+	| { file: FileData | FileData[]; alt_text: string | null }
+	| { component: string; value: any; constructor_args: any; props: any }
+	| null;
+
+export type TupleFormat = [message_data, message_data][] | null;
+
+export type NormalisedMessage = TextMessage | ComponentMessage;

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/column/package.json

@@ -0,0 +1,32 @@
+{
+	"name": "@gradio/column",
+	"version": "0.2.0",
+	"description": "Gradio UI packages",
+	"type": "module",
+	"author": "",
+	"license": "ISC",
+	"main_changeset": true,
+	"private": false,
+	"main": "./Index.svelte",
+	"exports": {
+		".": {
+			"gradio": "./Index.svelte",
+			"svelte": "./dist/Index.svelte",
+			"types": "./dist/Index.svelte.d.ts"
+		},
+		"./package.json": "./package.json"
+	},
+	"devDependencies": {
+		"@gradio/preview": "workspace:^",
+		"@gradio/statustracker": "workspace:^",
+		"@gradio/utils": "workspace:^"
+	},
+	"peerDependencies": {
+		"svelte": "^4.0.0"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "js/column"
+	}
+}

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/fallback/Example.svelte

@@ -0,0 +1,19 @@
+<script lang="ts">
+	export let value: string;
+	export let type: "gallery" | "table";
+	export let selected = false;
+</script>
+
+<div
+	class:table={type === "table"}
+	class:gallery={type === "gallery"}
+	class:selected
+>
+	{value}
+</div>
+
+<style>
+	.gallery {
+		padding: var(--size-1) var(--size-2);
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/fileexplorer/Index.svelte

@@ -0,0 +1,87 @@
+<svelte:options accessors={true} />
+
+<script lang="ts">
+	import type { Gradio, SelectData } from "@gradio/utils";
+	import { File } from "@gradio/icons";
+	import type { FileNode } from "./shared/types";
+
+	import { Block, BlockLabel } from "@gradio/atoms";
+	import DirectoryExplorer from "./shared/DirectoryExplorer.svelte";
+
+	import { StatusTracker } from "@gradio/statustracker";
+	import type { LoadingStatus } from "@gradio/statustracker";
+
+	import { _ } from "svelte-i18n";
+
+	export let elem_id = "";
+	export let elem_classes: string[] = [];
+	export let visible = true;
+	export let value: string[][];
+	let old_value: string[][];
+	export let label: string;
+	export let show_label: boolean;
+	export let height: number | string | undefined;
+	export let min_height: number | string | undefined;
+	export let max_height: number | string | undefined;
+	export let file_count: "single" | "multiple" = "multiple";
+	export let root_dir: string;
+	export let glob: string;
+	export let ignore_glob: string;
+	export let loading_status: LoadingStatus;
+	export let container = true;
+	export let scale: number | null = null;
+	export let min_width: number | undefined = undefined;
+	export let gradio: Gradio<{
+		change: never;
+		clear_status: LoadingStatus;
+	}>;
+	export let server: {
+		ls: (path: string[]) => Promise<FileNode[]>;
+	};
+	export let interactive: boolean;
+
+	$: rerender_key = [root_dir, glob, ignore_glob];
+
+	$: if (JSON.stringify(value) !== JSON.stringify(old_value)) {
+		old_value = value;
+		gradio.dispatch("change");
+	}
+</script>
+
+<Block
+	{visible}
+	variant={value === null ? "dashed" : "solid"}
+	border_mode={"base"}
+	padding={false}
+	{elem_id}
+	{elem_classes}
+	{container}
+	{scale}
+	{min_width}
+	allow_overflow={true}
+	overflow_behavior="auto"
+	{height}
+	{max_height}
+	{min_height}
+>
+	<StatusTracker
+		{...loading_status}
+		autoscroll={gradio.autoscroll}
+		i18n={gradio.i18n}
+		on:clear_status={() => gradio.dispatch("clear_status", loading_status)}
+	/>
+	<BlockLabel
+		{show_label}
+		Icon={File}
+		label={label || "FileExplorer"}
+		float={false}
+	/>
+	{#key rerender_key}
+		<DirectoryExplorer
+			bind:value
+			{file_count}
+			{interactive}
+			ls_fn={server.ls}
+		/>
+	{/key}
+</Block>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/fileexplorer/shared/Checkbox.svelte

@@ -0,0 +1,51 @@
+<script lang="ts">
+	import { createEventDispatcher } from "svelte";
+	export let value: boolean;
+	export let disabled: boolean;
+	const dispatch = createEventDispatcher<{ change: boolean }>();
+</script>
+
+<input
+	bind:checked={value}
+	on:input={() => dispatch("change", !value)}
+	type="checkbox"
+	{disabled}
+	class:disabled={disabled && !value}
+/>
+
+<style>
+	input {
+		--ring-color: transparent;
+		position: relative;
+		box-shadow: var(--input-shadow);
+		border: 1px solid var(--checkbox-border-color);
+		border-radius: var(--radius-xs);
+		background-color: var(--checkbox-background-color);
+		line-height: var(--line-sm);
+		width: 18px !important;
+		height: 18px !important;
+	}
+
+	input:checked,
+	input:checked:hover,
+	input:checked:focus {
+		border-color: var(--checkbox-border-color-selected);
+		background-image: var(--checkbox-check);
+		background-color: var(--checkbox-background-color-selected);
+	}
+
+	input:hover {
+		border-color: var(--checkbox-border-color-hover);
+		background-color: var(--checkbox-background-color-hover);
+	}
+
+	input:focus {
+		border-color: var(--checkbox-border-color-focus);
+		background-color: var(--checkbox-background-color-focus);
+	}
+
+	.disabled {
+		opacity: 0.8 !important;
+		cursor: not-allowed;
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/image/Index.svelte

@@ -0,0 +1,235 @@
+<svelte:options accessors={true} />
+
+<script context="module" lang="ts">
+	export { default as Webcam } from "./shared/Webcam.svelte";
+	export { default as BaseImageUploader } from "./shared/ImageUploader.svelte";
+	export { default as BaseStaticImage } from "./shared/ImagePreview.svelte";
+	export { default as BaseExample } from "./Example.svelte";
+	export { default as BaseImage } from "./shared/Image.svelte";
+</script>
+
+<script lang="ts">
+	import type { Gradio, SelectData, ValueData } from "@gradio/utils";
+	import StaticImage from "./shared/ImagePreview.svelte";
+	import ImageUploader from "./shared/ImageUploader.svelte";
+	import { afterUpdate } from "svelte";
+
+	import { Block, Empty, UploadText } from "@gradio/atoms";
+	import { Image } from "@gradio/icons";
+	import { StatusTracker } from "@gradio/statustracker";
+	import { upload, type FileData } from "@gradio/client";
+	import type { LoadingStatus } from "@gradio/statustracker";
+
+	type sources = "upload" | "webcam" | "clipboard" | null;
+
+	let stream_state = "closed";
+	let _modify_stream: (state: "open" | "closed" | "waiting") => void = () => {};
+	export function modify_stream_state(
+		state: "open" | "closed" | "waiting"
+	): void {
+		stream_state = state;
+		_modify_stream(state);
+	}
+	export const get_stream_state: () => void = () => stream_state;
+	export let set_time_limit: (arg0: number) => void;
+	export let value_is_output = false;
+	export let elem_id = "";
+	export let elem_classes: string[] = [];
+	export let visible = true;
+	export let value: null | FileData = null;
+	let old_value: null | FileData = null;
+	export let label: string;
+	export let show_label: boolean;
+	export let show_download_button: boolean;
+	export let root: string;
+
+	export let height: number | undefined;
+	export let width: number | undefined;
+	export let stream_every: number;
+
+	export let _selectable = false;
+	export let container = true;
+	export let scale: number | null = null;
+	export let min_width: number | undefined = undefined;
+	export let loading_status: LoadingStatus;
+	export let show_share_button = false;
+	export let sources: ("clipboard" | "webcam" | "upload")[] = [
+		"upload",
+		"clipboard",
+		"webcam"
+	];
+	export let interactive: boolean;
+	export let streaming: boolean;
+	export let pending: boolean;
+	export let mirror_webcam: boolean;
+	export let placeholder: string | undefined = undefined;
+	export let show_fullscreen_button: boolean;
+	export let input_ready: boolean;
+	let uploading = false;
+	$: input_ready = !uploading;
+	export let gradio: Gradio<{
+		input: never;
+		change: never;
+		error: string;
+		edit: never;
+		stream: ValueData;
+		drag: never;
+		upload: never;
+		clear: never;
+		select: SelectData;
+		share: ShareData;
+		clear_status: LoadingStatus;
+		close_stream: string;
+	}>;
+
+	$: {
+		if (JSON.stringify(value) !== JSON.stringify(old_value)) {
+			old_value = value;
+			gradio.dispatch("change");
+			if (!value_is_output) {
+				gradio.dispatch("input");
+			}
+		}
+	}
+
+	afterUpdate(() => {
+		value_is_output = false;
+	});
+
+	let dragging: boolean;
+	let active_source: sources = null;
+	let upload_component: ImageUploader;
+	const handle_drag_event = (event: Event): void => {
+		const drag_event = event as DragEvent;
+		drag_event.preventDefault();
+		drag_event.stopPropagation();
+		if (drag_event.type === "dragenter" || drag_event.type === "dragover") {
+			dragging = true;
+		} else if (drag_event.type === "dragleave") {
+			dragging = false;
+		}
+	};
+
+	const handle_drop = (event: Event): void => {
+		if (interactive) {
+			const drop_event = event as DragEvent;
+			drop_event.preventDefault();
+			drop_event.stopPropagation();
+			dragging = false;
+
+			if (upload_component) {
+				upload_component.loadFilesFromDrop(drop_event);
+			}
+		}
+	};
+</script>
+
+{#if !interactive}
+	<Block
+		{visible}
+		variant={"solid"}
+		border_mode={dragging ? "focus" : "base"}
+		padding={false}
+		{elem_id}
+		{elem_classes}
+		height={height || undefined}
+		{width}
+		allow_overflow={false}
+		{container}
+		{scale}
+		{min_width}
+	>
+		<StatusTracker
+			autoscroll={gradio.autoscroll}
+			i18n={gradio.i18n}
+			{...loading_status}
+		/>
+		<StaticImage
+			on:select={({ detail }) => gradio.dispatch("select", detail)}
+			on:share={({ detail }) => gradio.dispatch("share", detail)}
+			on:error={({ detail }) => gradio.dispatch("error", detail)}
+			{value}
+			{label}
+			{show_label}
+			{show_download_button}
+			selectable={_selectable}
+			{show_share_button}
+			i18n={gradio.i18n}
+			{show_fullscreen_button}
+		/>
+	</Block>
+{:else}
+	<Block
+		{visible}
+		variant={value === null ? "dashed" : "solid"}
+		border_mode={dragging ? "focus" : "base"}
+		padding={false}
+		{elem_id}
+		{elem_classes}
+		height={height || undefined}
+		{width}
+		allow_overflow={false}
+		{container}
+		{scale}
+		{min_width}
+		on:dragenter={handle_drag_event}
+		on:dragleave={handle_drag_event}
+		on:dragover={handle_drag_event}
+		on:drop={handle_drop}
+	>
+		<StatusTracker
+			autoscroll={gradio.autoscroll}
+			i18n={gradio.i18n}
+			{...loading_status}
+			on:clear_status={() => gradio.dispatch("clear_status", loading_status)}
+		/>
+
+		<ImageUploader
+			bind:this={upload_component}
+			bind:uploading
+			bind:active_source
+			bind:value
+			bind:dragging
+			selectable={_selectable}
+			{root}
+			{sources}
+			on:edit={() => gradio.dispatch("edit")}
+			on:clear={() => {
+				gradio.dispatch("clear");
+			}}
+			on:stream={({ detail }) => gradio.dispatch("stream", detail)}
+			on:drag={({ detail }) => (dragging = detail)}
+			on:upload={() => gradio.dispatch("upload")}
+			on:select={({ detail }) => gradio.dispatch("select", detail)}
+			on:share={({ detail }) => gradio.dispatch("share", detail)}
+			on:error={({ detail }) => {
+				loading_status = loading_status || {};
+				loading_status.status = "error";
+				gradio.dispatch("error", detail);
+			}}
+			on:close_stream={() => {
+				gradio.dispatch("close_stream", "stream");
+			}}
+			{label}
+			{show_label}
+			{pending}
+			{streaming}
+			{mirror_webcam}
+			{stream_every}
+			bind:modify_stream={_modify_stream}
+			bind:set_time_limit
+			max_file_size={gradio.max_file_size}
+			i18n={gradio.i18n}
+			upload={(...args) => gradio.client.upload(...args)}
+			stream_handler={gradio.client?.stream}
+		>
+			{#if active_source === "upload" || !active_source}
+				<UploadText i18n={gradio.i18n} type="image" {placeholder} />
+			{:else if active_source === "clipboard"}
+				<UploadText i18n={gradio.i18n} type="clipboard" mode="short" />
+			{:else}
+				<Empty unpadded_box={true} size="large"><Image /></Empty>
+			{/if}
+		</ImageUploader>
+	</Block>
+{/if}

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/image/package.json

@@ -0,0 +1,57 @@
+{
+	"name": "@gradio/image",
+	"version": "0.16.2",
+	"description": "Gradio UI packages",
+	"type": "module",
+	"author": "",
+	"license": "ISC",
+	"private": false,
+	"dependencies": {
+		"@gradio/atoms": "workspace:^",
+		"@gradio/client": "workspace:^",
+		"@gradio/icons": "workspace:^",
+		"@gradio/statustracker": "workspace:^",
+		"@gradio/upload": "workspace:^",
+		"@gradio/utils": "workspace:^",
+		"@gradio/wasm": "workspace:^",
+		"cropperjs": "^1.5.12",
+		"lazy-brush": "^1.0.1",
+		"resize-observer-polyfill": "^1.5.1"
+	},
+	"devDependencies": {
+		"@gradio/preview": "workspace:^"
+	},
+	"main_changeset": true,
+	"main": "./Index.svelte",
+	"exports": {
+		"./package.json": "./package.json",
+		".": {
+			"gradio": "./Index.svelte",
+			"svelte": "./dist/Index.svelte",
+			"types": "./dist/Index.svelte.d.ts"
+		},
+		"./example": {
+			"gradio": "./Example.svelte",
+			"svelte": "./dist/Example.svelte",
+			"types": "./dist/Example.svelte.d.ts"
+		},
+		"./base": {
+			"gradio": "./shared/ImagePreview.svelte",
+			"svelte": "./dist/shared/ImagePreview.svelte",
+			"types": "./dist/shared/ImagePreview.svelte.d.ts"
+		},
+		"./shared": {
+			"gradio": "./shared/index.ts",
+			"svelte": "./dist/shared/index.js",
+			"types": "./dist/shared/index.d.ts"
+		}
+	},
+	"peerDependencies": {
+		"svelte": "^4.0.0"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "js/image"
+	}
+}

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/image/shared/ClearImage.svelte

@@ -0,0 +1,18 @@
+<script lang="ts">
+	import { createEventDispatcher } from "svelte";
+	import { IconButton, IconButtonWrapper } from "@gradio/atoms";
+	import { Clear } from "@gradio/icons";
+
+	const dispatch = createEventDispatcher();
+</script>
+
+<IconButtonWrapper>
+	<IconButton
+		Icon={Clear}
+		label="Remove Image"
+		on:click={(event) => {
+			dispatch("remove_image");
+			event.stopPropagation();
+		}}
+	/>
+</IconButtonWrapper>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/image/shared/ImagePreview.svelte

@@ -0,0 +1,165 @@
+<script lang="ts">
+	import { createEventDispatcher, onMount } from "svelte";
+	import type { SelectData } from "@gradio/utils";
+	import { uploadToHuggingFace } from "@gradio/utils";
+	import {
+		BlockLabel,
+		Empty,
+		IconButton,
+		ShareButton,
+		IconButtonWrapper
+	} from "@gradio/atoms";
+	import { Download } from "@gradio/icons";
+	import { get_coordinates_of_clicked_image } from "./utils";
+	import Image from "./Image.svelte";
+	import { DownloadLink } from "@gradio/wasm/svelte";
+	import { Maximize, Minimize } from "@gradio/icons";
+
+	import { Image as ImageIcon } from "@gradio/icons";
+	import { type FileData } from "@gradio/client";
+	import type { I18nFormatter } from "@gradio/utils";
+
+	export let value: null | FileData;
+	export let label: string | undefined = undefined;
+	export let show_label: boolean;
+	export let show_download_button = true;
+	export let selectable = false;
+	export let show_share_button = false;
+	export let i18n: I18nFormatter;
+	export let show_fullscreen_button = true;
+
+	const dispatch = createEventDispatcher<{
+		change: string;
+		select: SelectData;
+	}>();
+
+	const handle_click = (evt: MouseEvent): void => {
+		let coordinates = get_coordinates_of_clicked_image(evt);
+		if (coordinates) {
+			dispatch("select", { index: coordinates, value: null });
+		}
+	};
+
+	let is_full_screen = false;
+	let image_container: HTMLElement;
+
+	onMount(() => {
+		document.addEventListener("fullscreenchange", () => {
+			is_full_screen = !!document.fullscreenElement;
+		});
+	});
+
+	const toggle_full_screen = async (): Promise<void> => {
+		if (!is_full_screen) {
+			await image_container.requestFullscreen();
+		} else {
+			await document.exitFullscreen();
+			is_full_screen = !is_full_screen;
+		}
+	};
+</script>
+
+<BlockLabel
+	{show_label}
+	Icon={ImageIcon}
+	label={!show_label ? "" : label || i18n("image.image")}
+/>
+{#if value === null || !value.url}
+	<Empty unpadded_box={true} size="large"><ImageIcon /></Empty>
+{:else}
+	<div class="image-container" bind:this={image_container}>
+		<IconButtonWrapper>
+			{#if !is_full_screen && show_fullscreen_button}
+				<IconButton
+					Icon={Maximize}
+					label={is_full_screen ? "Exit full screen" : "View in full screen"}
+					on:click={toggle_full_screen}
+				/>
+			{/if}
+
+			{#if is_full_screen && show_fullscreen_button}
+				<IconButton
+					Icon={Minimize}
+					label={is_full_screen ? "Exit full screen" : "View in full screen"}
+					on:click={toggle_full_screen}
+				/>
+			{/if}
+
+			{#if show_download_button}
+				<DownloadLink href={value.url} download={value.orig_name || "image"}>
+					<IconButton Icon={Download} label={i18n("common.download")} />
+				</DownloadLink>
+			{/if}
+			{#if show_share_button}
+				<ShareButton
+					{i18n}
+					on:share
+					on:error
+					formatter={async (value) => {
+						if (!value) return "";
+						let url = await uploadToHuggingFace(value, "url");
+						return `<img src="${url}" />`;
+					}}
+					{value}
+				/>
+			{/if}
+		</IconButtonWrapper>
+		<button on:click={handle_click}>
+			<div class:selectable class="image-frame">
+				<Image src={value.url} alt="" loading="lazy" on:load />
+			</div>
+		</button>
+	</div>
+{/if}
+
+<style>
+	.image-container {
+		height: 100%;
+		position: relative;
+	}
+
+	.image-container button {
+		width: var(--size-full);
+		height: var(--size-full);
+		border-radius: var(--radius-lg);
+
+		display: flex;
+		align-items: center;
+		justify-content: center;
+	}
+
+	.image-frame {
+		width: auto;
+		height: 100%;
+		display: flex;
+		align-items: center;
+		justify-content: center;
+	}
+	.image-frame :global(img) {
+		width: var(--size-full);
+		height: var(--size-full);
+		object-fit: scale-down;
+	}
+
+	.selectable {
+		cursor: crosshair;
+	}
+
+	:global(.fullscreen-controls svg) {
+		position: relative;
+		top: 0px;
+	}
+
+	:global(.image-container:fullscreen) {
+		background-color: black;
+		display: flex;
+		justify-content: center;
+		align-items: center;
+	}
+
+	:global(.image-container:fullscreen img) {
+		max-width: 90vw;
+		max-height: 90vh;
+		object-fit: scale-down;
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/image/shared/ImageUploader.svelte

@@ -0,0 +1,235 @@
+<script lang="ts">
+	import { createEventDispatcher, tick } from "svelte";
+	import { BlockLabel } from "@gradio/atoms";
+	import { Image as ImageIcon } from "@gradio/icons";
+	import {
+		type SelectData,
+		type I18nFormatter,
+		type ValueData
+	} from "@gradio/utils";
+	import { get_coordinates_of_clicked_image } from "./utils";
+	import Webcam from "./Webcam.svelte";
+
+	import { Upload } from "@gradio/upload";
+	import { FileData, type Client } from "@gradio/client";
+	import ClearImage from "./ClearImage.svelte";
+	import { SelectSource } from "@gradio/atoms";
+	import Image from "./Image.svelte";
+	import type { Base64File } from "./types";
+
+	export let value: null | FileData | Base64File = null;
+	export let label: string | undefined = undefined;
+	export let show_label: boolean;
+
+	type source_type = "upload" | "webcam" | "clipboard" | "microphone" | null;
+
+	export let sources: source_type[] = ["upload", "clipboard", "webcam"];
+	export let streaming = false;
+	export let pending = false;
+	export let mirror_webcam: boolean;
+	export let selectable = false;
+	export let root: string;
+	export let i18n: I18nFormatter;
+	export let max_file_size: number | null = null;
+	export let upload: Client["upload"];
+	export let stream_handler: Client["stream"];
+	export let stream_every: number;
+
+	export let modify_stream: (state: "open" | "closed" | "waiting") => void;
+	export let set_time_limit: (arg0: number) => void;
+
+	let upload_input: Upload;
+	export let uploading = false;
+	export let active_source: source_type = null;
+
+	function handle_upload({ detail }: CustomEvent<FileData>): void {
+		// only trigger streaming event if streaming
+		if (!streaming) {
+			value = detail;
+			dispatch("upload");
+		}
+	}
+
+	function handle_clear(): void {
+		value = null;
+		dispatch("clear");
+		dispatch("change", null);
+	}
+
+	async function handle_save(
+		img_blob: Blob | any,
+		event: "change" | "stream" | "upload"
+	): Promise<void> {
+		if (event === "stream") {
+			dispatch("stream", {
+				value: { url: img_blob } as Base64File,
+				is_value_data: true
+			});
+			return;
+		}
+		pending = true;
+		const f = await upload_input.load_files([
+			new File([img_blob], `image/${streaming ? "jpeg" : "png"}`)
+		]);
+
+		if (event === "change" || event === "upload") {
+			value = f?.[0] || null;
+			await tick();
+			dispatch("change");
+		}
+		pending = false;
+	}
+
+	$: active_streaming = streaming && active_source === "webcam";
+	$: if (uploading && !active_streaming) value = null;
+
+	const dispatch = createEventDispatcher<{
+		change?: never;
+		stream: ValueData;
+		clear?: never;
+		drag: boolean;
+		upload?: never;
+		select: SelectData;
+		end_stream: never;
+	}>();
+
+	export let dragging = false;
+
+	$: dispatch("drag", dragging);
+
+	function handle_click(evt: MouseEvent): void {
+		let coordinates = get_coordinates_of_clicked_image(evt);
+		if (coordinates) {
+			dispatch("select", { index: coordinates, value: null });
+		}
+	}
+
+	$: if (!active_source && sources) {
+		active_source = sources[0];
+	}
+
+	async function handle_select_source(
+		source: (typeof sources)[number]
+	): Promise<void> {
+		switch (source) {
+			case "clipboard":
+				upload_input.paste_clipboard();
+				break;
+			default:
+				break;
+		}
+	}
+</script>
+
+<BlockLabel {show_label} Icon={ImageIcon} label={label || "Image"} />
+
+<div data-testid="image" class="image-container">
+	{#if value?.url && !active_streaming}
+		<ClearImage
+			on:remove_image={() => {
+				value = null;
+				dispatch("clear");
+			}}
+		/>
+	{/if}
+	<div
+		class="upload-container"
+		class:reduced-height={sources.length > 1}
+		style:width={value ? "auto" : "100%"}
+	>
+		<Upload
+			hidden={value !== null || active_source === "webcam"}
+			bind:this={upload_input}
+			bind:uploading
+			bind:dragging
+			filetype={active_source === "clipboard" ? "clipboard" : "image/*"}
+			on:load={handle_upload}
+			on:error
+			{root}
+			{max_file_size}
+			disable_click={!sources.includes("upload") || value !== null}
+			{upload}
+			{stream_handler}
+		>
+			{#if value === null}
+				<slot />
+			{/if}
+		</Upload>
+		{#if active_source === "webcam" && (streaming || (!streaming && !value))}
+			<Webcam
+				{root}
+				{value}
+				on:capture={(e) => handle_save(e.detail, "change")}
+				on:stream={(e) => handle_save(e.detail, "stream")}
+				on:error
+				on:drag
+				on:upload={(e) => handle_save(e.detail, "upload")}
+				on:close_stream
+				{mirror_webcam}
+				{stream_every}
+				{streaming}
+				mode="image"
+				include_audio={false}
+				{i18n}
+				{upload}
+				bind:modify_stream
+				bind:set_time_limit
+			/>
+		{:else if value !== null && !streaming}
+			<!-- svelte-ignore a11y-click-events-have-key-events-->
+			<!-- svelte-ignore a11y-no-static-element-interactions-->
+			<div class:selectable class="image-frame" on:click={handle_click}>
+				<Image src={value.url} alt={value.alt_text} />
+			</div>
+		{/if}
+	</div>
+	{#if sources.length > 1 || sources.includes("clipboard")}
+		<SelectSource
+			{sources}
+			bind:active_source
+			{handle_clear}
+			handle_select={handle_select_source}
+		/>
+	{/if}
+</div>
+
+<style>
+	.image-frame :global(img) {
+		width: var(--size-full);
+		height: var(--size-full);
+		object-fit: scale-down;
+	}
+
+	.image-frame {
+		object-fit: cover;
+		width: 100%;
+		height: 100%;
+	}
+
+	.upload-container {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+
+		height: 100%;
+		flex-shrink: 1;
+		max-height: 100%;
+	}
+
+	.reduced-height {
+		height: calc(100% - var(--size-10));
+	}
+
+	.image-container {
+		display: flex;
+		height: 100%;
+		flex-direction: column;
+		justify-content: center;
+		align-items: center;
+		max-height: 100%;
+	}
+
+	.selectable {
+		cursor: crosshair;
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/image/shared/index.ts

@@ -0,0 +1,2 @@
+export { default as Image } from "./Image.svelte";
+export { default as StaticImage } from "./ImagePreview.svelte";

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/image/shared/utils.ts

@@ -0,0 +1,29 @@
+export const get_coordinates_of_clicked_image = (
+	evt: MouseEvent
+): [number, number] | null => {
+	let image;
+	if (evt.currentTarget instanceof Element) {
+		image = evt.currentTarget.querySelector("img") as HTMLImageElement;
+	} else {
+		return [NaN, NaN];
+	}
+
+	const imageRect = image.getBoundingClientRect();
+	const xScale = image.naturalWidth / imageRect.width;
+	const yScale = image.naturalHeight / imageRect.height;
+	if (xScale > yScale) {
+		const displayed_height = image.naturalHeight / xScale;
+		const y_offset = (imageRect.height - displayed_height) / 2;
+		var x = Math.round((evt.clientX - imageRect.left) * xScale);
+		var y = Math.round((evt.clientY - imageRect.top - y_offset) * xScale);
+	} else {
+		const displayed_width = image.naturalWidth / yScale;
+		const x_offset = (imageRect.width - displayed_width) / 2;
+		var x = Math.round((evt.clientX - imageRect.left - x_offset) * yScale);
+		var y = Math.round((evt.clientY - imageRect.top) * yScale);
+	}
+	if (x < 0 || x >= image.naturalWidth || y < 0 || y >= image.naturalHeight) {
+		return null;
+	}
+	return [x, y];
+};

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/plot/Index.svelte

@@ -0,0 +1,73 @@
+<script context="module" lang="ts">
+	export { default as BasePlot } from "./shared/Plot.svelte";
+</script>
+
+<script lang="ts">
+	import type { Gradio, SelectData } from "@gradio/utils";
+	import Plot from "./shared/Plot.svelte";
+
+	import { Block, BlockLabel } from "@gradio/atoms";
+	import { Plot as PlotIcon } from "@gradio/icons";
+
+	import { StatusTracker } from "@gradio/statustracker";
+	import type { LoadingStatus } from "@gradio/statustracker";
+
+	type ThemeMode = "system" | "light" | "dark";
+
+	export let value: null | string = null;
+	export let elem_id = "";
+	export let elem_classes: string[] = [];
+	export let visible = true;
+	export let loading_status: LoadingStatus;
+	export let label: string;
+	export let show_label: boolean;
+	export let container = true;
+	export let scale: number | null = null;
+	export let min_width: number | undefined = undefined;
+	export let theme_mode: ThemeMode;
+	export let caption: string;
+	export let bokeh_version: string | null;
+	export let gradio: Gradio<{
+		change: never;
+		clear_status: LoadingStatus;
+		select: SelectData;
+	}>;
+	export let show_actions_button = false;
+	export let _selectable = false;
+	export let x_lim: [number, number] | null = null;
+</script>
+
+<Block
+	padding={false}
+	{elem_id}
+	{elem_classes}
+	{visible}
+	{container}
+	{scale}
+	{min_width}
+	allow_overflow={false}
+>
+	<BlockLabel
+		{show_label}
+		label={label || gradio.i18n("plot.plot")}
+		Icon={PlotIcon}
+	/>
+	<StatusTracker
+		autoscroll={gradio.autoscroll}
+		i18n={gradio.i18n}
+		{...loading_status}
+		on:clear_status={() => gradio.dispatch("clear_status", loading_status)}
+	/>
+	<Plot
+		{value}
+		{theme_mode}
+		{caption}
+		{bokeh_version}
+		{show_actions_button}
+		{gradio}
+		{_selectable}
+		{x_lim}
+		on:change={() => gradio.dispatch("change")}
+		on:select={(e) => gradio.dispatch("select", e.detail)}
+	/>
+</Block>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/plot/package.json

@@ -0,0 +1,47 @@
+{
+	"name": "@gradio/plot",
+	"version": "0.7.1",
+	"description": "Gradio UI packages",
+	"type": "module",
+	"author": "",
+	"license": "ISC",
+	"private": false,
+	"dependencies": {
+		"@gradio/atoms": "workspace:^",
+		"@gradio/icons": "workspace:^",
+		"@gradio/statustracker": "workspace:^",
+		"@gradio/theme": "workspace:^",
+		"@gradio/utils": "workspace:^",
+		"@rollup/plugin-json": "^6.0.0",
+		"plotly.js-dist-min": "^2.10.1",
+		"vega": "^5.23.0",
+		"vega-embed": "^6.25.0",
+		"vega-lite": "^5.12.0"
+	},
+	"devDependencies": {
+		"@gradio/preview": "workspace:^"
+	},
+	"main": "./Index.svelte",
+	"main_changeset": true,
+	"exports": {
+		"./package.json": "./package.json",
+		".": {
+			"gradio": "./Index.svelte",
+			"svelte": "./dist/Index.svelte",
+			"types": "./dist/Index.svelte.d.ts"
+		},
+		"./base": {
+			"gradio": "./shared/Plot.svelte",
+			"svelte": "./dist/shared/Plot.svelte",
+			"types": "./dist/shared/Plot.svelte.d.ts"
+		}
+	},
+	"peerDependencies": {
+		"svelte": "^4.0.0"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "js/plot"
+	}
+}

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/plot/shared/Plot.svelte

@@ -0,0 +1,62 @@
+<script lang="ts">
+	//@ts-nocheck
+	import { Plot as PlotIcon } from "@gradio/icons";
+	import { Empty } from "@gradio/atoms";
+	import type { ThemeMode } from "js/core/src/components/types";
+	import type { Gradio, SelectData } from "@gradio/utils";
+
+	export let value;
+	export let colors: string[] = [];
+	export let theme_mode: ThemeMode;
+	export let caption: string;
+	export let bokeh_version: string | null;
+	export let show_actions_button: bool;
+	export let gradio: Gradio<{
+		select: SelectData;
+	}>;
+	export let x_lim: [number, number] | null = null;
+	export let _selectable: boolean;
+
+	let PlotComponent: any = null;
+	let _type = value?.type;
+
+	const plotTypeMapping = {
+		plotly: () => import("./plot_types/PlotlyPlot.svelte"),
+		bokeh: () => import("./plot_types/BokehPlot.svelte"),
+		altair: () => import("./plot_types/AltairPlot.svelte"),
+		matplotlib: () => import("./plot_types/MatplotlibPlot.svelte")
+	};
+
+	const is_browser = typeof window !== "undefined";
+
+	$: {
+		let type = value?.type;
+		if (type !== _type) {
+			PlotComponent = null;
+		}
+		if (type && type in plotTypeMapping && is_browser) {
+			plotTypeMapping[type]().then((module) => {
+				PlotComponent = module.default;
+			});
+		}
+	}
+</script>
+
+{#if value && PlotComponent}
+	<svelte:component
+		this={PlotComponent}
+		{value}
+		{colors}
+		{theme_mode}
+		{caption}
+		{bokeh_version}
+		{show_actions_button}
+		{gradio}
+		{_selectable}
+		{x_lim}
+		on:load
+		on:select
+	/>
+{:else}
+	<Empty unpadded_box={true} size="large"><PlotIcon /></Empty>
+{/if}

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/plot/shared/plot_types/AltairPlot.svelte

@@ -0,0 +1,157 @@
+<script lang="ts">
+	//@ts-nocheck
+	import { set_config } from "./altair_utils";
+	import { onMount, onDestroy } from "svelte";
+	import type { TopLevelSpec as Spec } from "vega-lite";
+	import vegaEmbed from "vega-embed";
+	import type { Gradio, SelectData } from "@gradio/utils";
+	import type { View } from "vega";
+
+	export let value;
+	export let colors: string[] = [];
+	export let caption: string;
+	export let show_actions_button: bool;
+	export let gradio: Gradio<{
+		select: SelectData;
+	}>;
+	let element: HTMLElement;
+	let parent_element: HTMLElement;
+	let view: View;
+	export let _selectable: bool;
+
+	let computed_style = window.getComputedStyle(document.body);
+
+	let old_spec: Spec;
+	let spec_width: number;
+	$: plot = value?.plot;
+	$: spec = JSON.parse(plot) as Spec;
+	$: if (spec && spec.params && !_selectable) {
+		spec.params = spec.params.filter((param) => param.name !== "brush");
+	}
+	$: if (old_spec !== spec) {
+		old_spec = spec;
+		spec_width = spec.width;
+	}
+
+	$: if (value.chart) {
+		spec = set_config(spec, computed_style, value.chart as string, colors);
+	}
+	$: fit_width_to_parent =
+		spec.encoding?.column?.field ||
+		spec.encoding?.row?.field ||
+		value.chart === undefined
+			? false
+			: true; // vega seems to glitch with width when orientation is set
+
+	const get_width = (): number => {
+		return Math.min(
+			parent_element.offsetWidth,
+			spec_width || parent_element.offsetWidth
+		);
+	};
+	let resize_callback = (): void => {};
+	const renderPlot = (): void => {
+		if (fit_width_to_parent) {
+			spec.width = get_width();
+		}
+		vegaEmbed(element, spec, { actions: show_actions_button }).then(
+			function (result): void {
+				view = result.view;
+				resize_callback = () => {
+					view.signal("width", get_width()).run();
+				};
+
+				if (!_selectable) return;
+				const callback = (event, item): void => {
+					const brushValue = view.signal("brush");
+					if (brushValue) {
+						if (Object.keys(brushValue).length === 0) {
+							gradio.dispatch("select", {
+								value: null,
+								index: null,
+								selected: false
+							});
+						} else {
+							const key = Object.keys(brushValue)[0];
+							let range: [number, number] = brushValue[key].map(
+								(x) => x / 1000
+							);
+							gradio.dispatch("select", {
+								value: brushValue,
+								index: range,
+								selected: true
+							});
+						}
+					}
+				};
+				view.addEventListener("mouseup", callback);
+				view.addEventListener("touchup", callback);
+			}
+		);
+	};
+	let resizeObserver = new ResizeObserver(() => {
+		if (fit_width_to_parent && spec.width !== parent_element.offsetWidth) {
+			resize_callback();
+		}
+	});
+	onMount(() => {
+		renderPlot();
+		resizeObserver.observe(parent_element);
+	});
+	onDestroy(() => {
+		resizeObserver.disconnect();
+	});
+</script>
+
+<div data-testid={"altair"} class="altair layout" bind:this={parent_element}>
+	<div bind:this={element}></div>
+	{#if caption}
+		<div class="caption layout">
+			{caption}
+		</div>
+	{/if}
+</div>
+
+<style>
+	.altair :global(canvas) {
+		padding: 6px;
+	}
+	.altair :global(.vega-embed) {
+		padding: 0px !important;
+	}
+	.altair :global(.vega-actions) {
+		right: 0px !important;
+	}
+	.layout {
+		display: flex;
+		flex-direction: column;
+		justify-content: center;
+		align-items: center;
+		width: var(--size-full);
+		height: var(--size-full);
+		color: var(--body-text-color);
+	}
+	.altair {
+		display: flex;
+		flex-direction: column;
+		justify-content: center;
+		align-items: center;
+		width: var(--size-full);
+		height: var(--size-full);
+	}
+	.caption {
+		font-size: var(--text-sm);
+		margin-bottom: 6px;
+	}
+	:global(#vg-tooltip-element) {
+		font-family: var(--font) !important;
+		font-size: var(--text-xs) !important;
+		box-shadow: none !important;
+		background-color: var(--block-background-fill) !important;
+		border: 1px solid var(--border-color-primary) !important;
+		color: var(--body-text-color) !important;
+	}
+	:global(#vg-tooltip-element .key) {
+		color: var(--body-text-color-subdued) !important;
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/plot/shared/plot_types/MatplotlibPlot.svelte

@@ -0,0 +1,28 @@
+<script lang="ts">
+	export let value;
+
+	$: plot = value?.plot;
+</script>
+
+<div data-testid={"matplotlib"} class="matplotlib layout">
+	<img
+		src={plot}
+		alt={`${value.chart} plot visualising provided data`}
+		on:load
+	/>
+</div>
+
+<style>
+	.layout {
+		display: flex;
+		flex-direction: column;
+		justify-content: center;
+		align-items: center;
+		width: var(--size-full);
+		height: var(--size-full);
+		color: var(--body-text-color);
+	}
+	.matplotlib img {
+		object-fit: contain;
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/plot/shared/plot_types/PlotlyPlot.svelte

@@ -0,0 +1,50 @@
+<script lang="ts">
+	//@ts-nocheck
+	import Plotly from "plotly.js-dist-min";
+	import { afterUpdate, createEventDispatcher } from "svelte";
+
+	export let value;
+
+	$: plot = value?.plot;
+
+	let plot_div;
+	let plotly_global_style;
+
+	const dispatch = createEventDispatcher<{ load: undefined }>();
+
+	function load_plotly_css(): void {
+		if (!plotly_global_style) {
+			plotly_global_style = document.getElementById("plotly.js-style-global");
+			const plotly_style_clone = plotly_global_style.cloneNode();
+			plot_div.appendChild(plotly_style_clone);
+			for (const rule of plotly_global_style.sheet.cssRules) {
+				plotly_style_clone.sheet.insertRule(rule.cssText);
+			}
+		}
+	}
+
+	afterUpdate(async () => {
+		load_plotly_css();
+
+		let plotObj = JSON.parse(plot);
+
+		// the docs aren't very good but this works
+		plotObj.config = plotObj.config || {};
+		plotObj.config.responsive = true;
+		plotObj.responsive = true;
+		plotObj.layout.autosize = true;
+
+		plotObj.layout.title
+			? (plotObj.layout.margin = { autoexpand: true })
+			: (plotObj.layout.margin = { l: 0, r: 0, b: 0, t: 0 });
+
+		Plotly.react(plot_div, plotObj.data, plotObj.layout, plotObj.config);
+		Plotly.Plots.resize(plot_div);
+
+		plot_div.on("plotly_afterplot", () => {
+			dispatch("load");
+		});
+	});
+</script>
+
+<div data-testid={"plotly"} bind:this={plot_div} />

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/preview/package.json

@@ -0,0 +1,54 @@
+{
+	"name": "@gradio/preview",
+	"version": "0.12.0",
+	"description": "Gradio UI packages",
+	"type": "module",
+	"main": "dist/index.js",
+	"author": "",
+	"license": "ISC",
+	"private": false,
+	"scripts": {
+		"build:rollup": "rollup -c",
+		"build:vite": "vite build --ssr",
+		"build": "pnpm build:rollup && pnpm build:vite"
+	},
+	"devDependencies": {
+		"@rollup/plugin-commonjs": "^25.0.4",
+		"@rollup/plugin-json": "^6.0.0",
+		"@rollup/plugin-node-resolve": "^15.1.0",
+		"@rollup/plugin-typescript": "^11.1.2",
+		"rollup": "^3.28.0"
+	},
+	"dependencies": {
+		"@originjs/vite-plugin-commonjs": "^1.0.3",
+		"@rollup/plugin-sucrase": "^5.0.1",
+		"@sveltejs/vite-plugin-svelte": "^3.1.0",
+		"@types/which": "^3.0.0",
+		"coffeescript": "^2.7.0",
+		"lightningcss": "^1.21.7",
+		"pug": "^3.0.2",
+		"sass": "^1.66.1",
+		"stylus": "^0.63.0",
+		"sucrase": "^3.34.0",
+		"sugarss": "^4.0.1",
+		"svelte-hmr": "^0.16.0",
+		"svelte-preprocess": "^5.0.4",
+		"typescript": "^5.0.0",
+		"vite": "^5.2.9",
+		"which": "4.0.0",
+		"yootils": "^0.3.1"
+	},
+	"optionalDependencies": {
+		"svelte": "^4.0.0"
+	},
+	"exports": {
+		".": {
+			"default": "./dist/index.js",
+			"import": "./dist/index.js",
+			"gradio": "./src/index.ts",
+			"svelte": "./dist/src/index.js",
+			"types": "./dist/index.d.ts"
+		},
+		"./package.json": "./package.json"
+	}
+}

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/preview/rollup.config.js

@@ -0,0 +1,54 @@
+// @ts-nocheck
+import { createRequire } from "node:module";
+import { join } from "path";
+
+import ts from "@rollup/plugin-typescript";
+import node from "@rollup/plugin-node-resolve";
+import cjs from "@rollup/plugin-commonjs";
+import json from "@rollup/plugin-json";
+
+const onwarn = (warning, warn) => {
+	if (warning.plugin === "typescript") return;
+	if (warning.code === "CIRCULAR_DEPENDENCY") return;
+	if (warning.code === "EVAL") return;
+
+	warn(warning);
+};
+
+const require = createRequire(import.meta.url);
+const dir = require.resolve("./package.json");
+
+const output_svelte_dir = join(
+	dir,
+	"..",
+	"..",
+	"..",
+	"gradio",
+	"templates",
+	"frontend",
+	"assets",
+	"svelte"
+);
+
+const plugins = [node({ preferBuiltins: true }), json(), cjs(), ts()];
+
+export default [
+	{
+		input: "src/svelte-submodules.ts",
+		output: {
+			file: join(output_svelte_dir, "svelte-submodules.js"),
+			format: "esm"
+		},
+		onwarn,
+		plugins
+	},
+	{
+		input: "src/svelte-internal.ts",
+		output: {
+			file: join(output_svelte_dir, "svelte.js"),
+			format: "esm"
+		},
+		onwarn,
+		plugins
+	}
+];

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/preview/src/build.ts

@@ -0,0 +1,108 @@
+import * as fs from "fs";
+import { join } from "path";
+import { build } from "vite";
+import { plugins, make_gradio_plugin } from "./plugins";
+import type { PreRenderedChunk } from "rollup";
+import { examine_module } from "./index";
+
+interface BuildOptions {
+	component_dir: string;
+	root_dir: string;
+	python_path: string;
+}
+
+export async function make_build({
+	component_dir,
+	root_dir,
+	python_path
+}: BuildOptions): Promise<void> {
+	process.env.gradio_mode = "dev";
+	const svelte_dir = join(root_dir, "assets", "svelte");
+
+	const module_meta = examine_module(
+		component_dir,
+		root_dir,
+		python_path,
+		"build"
+	);
+	try {
+		for (const comp of module_meta) {
+			const template_dir = comp.template_dir;
+			const source_dir = comp.frontend_dir;
+
+			const pkg = JSON.parse(
+				fs.readFileSync(join(source_dir, "package.json"), "utf-8")
+			);
+			let component_config = {
+				plugins: [],
+				svelte: {
+					preprocess: []
+				},
+				build: {
+					target: []
+				},
+				optimizeDeps: {}
+			};
+
+			if (
+				comp.frontend_dir &&
+				fs.existsSync(join(comp.frontend_dir, "gradio.config.js"))
+			) {
+				const m = await import(
+					join("file://" + comp.frontend_dir, "gradio.config.js")
+				);
+
+				component_config.plugins = m.default.plugins || [];
+				component_config.svelte.preprocess = m.default.svelte?.preprocess || [];
+				component_config.build.target = m.default.build?.target || "modules";
+				component_config.optimizeDeps = m.default.optimizeDeps || {};
+			}
+
+			const exports: (string | any)[][] = [
+				["component", pkg.exports["."] as object],
+				["example", pkg.exports["./example"] as object]
+			].filter(([_, path]) => !!path);
+
+			for (const [entry, path] of exports) {
+				try {
+					const x = await build({
+						root: source_dir,
+						configFile: false,
+						plugins: [
+							...plugins(component_config),
+							make_gradio_plugin({ mode: "build", svelte_dir })
+						],
+						resolve: {
+							conditions: ["gradio"]
+						},
+						build: {
+							target: component_config.build.target,
+							emptyOutDir: true,
+							outDir: join(template_dir, entry as string),
+							lib: {
+								entry: join(source_dir, (path as any).gradio),
+								fileName: "index.js",
+								formats: ["es"]
+							},
+							minify: true,
+							rollupOptions: {
+								output: {
+									entryFileNames: (chunkInfo: PreRenderedChunk) => {
+										if (chunkInfo.isEntry) {
+											return "index.js";
+										}
+										return `${chunkInfo.name.toLocaleLowerCase()}.js`;
+									}
+								}
+							}
+						}
+					});
+				} catch (e) {
+					throw e;
+				}
+			}
+		}
+	} catch (e) {
+		throw e;
+	}
+}

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/preview/src/compiler.ts

@@ -0,0 +1,2 @@
+export * from "svelte/compiler";
+export * as default from "svelte/compiler";

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/preview/src/dev.ts

@@ -0,0 +1,207 @@
+import { join } from "path";
+import * as fs from "fs";
+import { createServer, createLogger } from "vite";
+import { plugins, make_gradio_plugin } from "./plugins";
+import { examine_module } from "./index";
+import type { PreprocessorGroup } from "svelte/compiler";
+
+const vite_messages_to_ignore = [
+	"Default and named imports from CSS files are deprecated.",
+	"The above dynamic import cannot be analyzed by Vite."
+];
+
+const logger = createLogger();
+const originalWarning = logger.warn;
+logger.warn = (msg, options) => {
+	if (vite_messages_to_ignore.some((m) => msg.includes(m))) return;
+
+	originalWarning(msg, options);
+};
+
+interface ServerOptions {
+	component_dir: string;
+	root_dir: string;
+	frontend_port: number;
+	backend_port: number;
+	host: string;
+	python_path: string;
+}
+
+export async function create_server({
+	component_dir,
+	root_dir,
+	frontend_port,
+	backend_port,
+	host,
+	python_path
+}: ServerOptions): Promise<void> {
+	process.env.gradio_mode = "dev";
+	const [imports, config] = await generate_imports(
+		component_dir,
+		root_dir,
+		python_path
+	);
+
+	const svelte_dir = join(root_dir, "assets", "svelte");
+
+	try {
+		const server = await createServer({
+			customLogger: logger,
+			mode: "development",
+			configFile: false,
+			root: root_dir,
+			server: {
+				port: frontend_port,
+				host: host,
+				fs: {
+					allow: [root_dir, component_dir]
+				}
+			},
+			resolve: {
+				conditions: ["gradio"]
+			},
+			build: {
+				target: config.build.target
+			},
+			optimizeDeps: config.optimizeDeps,
+			plugins: [
+				...plugins(config),
+				make_gradio_plugin({
+					mode: "dev",
+					backend_port,
+					svelte_dir,
+					imports
+				})
+			]
+		});
+
+		await server.listen();
+
+		console.info(
+			`[orange3]Frontend Server[/] (Go here): ${server.resolvedUrls?.local}`
+		);
+	} catch (e) {
+		console.error(e);
+	}
+}
+
+function find_frontend_folders(start_path: string): string[] {
+	if (!fs.existsSync(start_path)) {
+		console.warn("No directory found at:", start_path);
+		return [];
+	}
+
+	if (fs.existsSync(join(start_path, "pyproject.toml"))) return [start_path];
+
+	const results: string[] = [];
+	const dir = fs.readdirSync(start_path);
+	dir.forEach((dir) => {
+		const filepath = join(start_path, dir);
+		if (fs.existsSync(filepath)) {
+			if (fs.existsSync(join(filepath, "pyproject.toml")))
+				results.push(filepath);
+		}
+	});
+
+	return results;
+}
+
+function to_posix(_path: string): string {
+	const isExtendedLengthPath = /^\\\\\?\\/.test(_path);
+	const hasNonAscii = /[^\u0000-\u0080]+/.test(_path);
+
+	if (isExtendedLengthPath || hasNonAscii) {
+		return _path;
+	}
+
+	return _path.replace(/\\/g, "/");
+}
+
+export interface ComponentConfig {
+	plugins: any[];
+	svelte: {
+		preprocess: PreprocessorGroup[];
+		extensions?: string[];
+	};
+	build: {
+		target: string | string[];
+	};
+	optimizeDeps: object;
+}
+
+async function generate_imports(
+	component_dir: string,
+	root: string,
+	python_path: string
+): Promise<[string, ComponentConfig]> {
+	const components = find_frontend_folders(component_dir);
+
+	const component_entries = components.flatMap((component) => {
+		return examine_module(component, root, python_path, "dev");
+	});
+	if (component_entries.length === 0) {
+		console.info(
+			`No custom components were found in ${component_dir}. It is likely that dev mode does not work properly. Please pass the --gradio-path and --python-path CLI arguments so that gradio uses the right executables.`
+		);
+	}
+
+	let component_config: ComponentConfig = {
+		plugins: [],
+		svelte: {
+			preprocess: []
+		},
+		build: {
+			target: []
+		},
+		optimizeDeps: {}
+	};
+
+	await Promise.all(
+		component_entries.map(async (component) => {
+			if (
+				component.frontend_dir &&
+				fs.existsSync(join(component.frontend_dir, "gradio.config.js"))
+			) {
+				const m = await import(
+					join("file://" + component.frontend_dir, "gradio.config.js")
+				);
+
+				component_config.plugins = m.default.plugins || [];
+				component_config.svelte.preprocess = m.default.svelte?.preprocess || [];
+				component_config.build.target = m.default.build?.target || "modules";
+				component_config.optimizeDeps = m.default.optimizeDeps || {};
+			} else {
+			}
+		})
+	);
+
+	const imports = component_entries.reduce((acc, component) => {
+		const pkg = JSON.parse(
+			fs.readFileSync(join(component.frontend_dir, "package.json"), "utf-8")
+		);
+
+		const exports: Record<string, any | undefined> = {
+			component: pkg.exports["."],
+			example: pkg.exports["./example"]
+		};
+
+		if (!exports.component)
+			throw new Error(
+				"Could not find component entry point. Please check the exports field of your package.json."
+			);
+
+		const example = exports.example
+			? `example: () => import("/@fs/${to_posix(
+					join(component.frontend_dir, exports.example.gradio)
+				)}"),\n`
+			: "";
+		return `${acc}"${component.component_class_id}": {
+			${example}
+			component: () => import("/@fs/${to_posix(
+				join(component.frontend_dir, exports.component.gradio)
+			)}")
+			},\n`;
+	}, "");
+
+	return [`{${imports}}`, component_config];
+}

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/preview/src/index.ts

@@ -0,0 +1,197 @@
+import { type ChildProcess, spawn, spawnSync } from "node:child_process";
+import * as net from "net";
+
+import { create_server, type ComponentConfig } from "./dev";
+import { make_build } from "./build";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+export interface ComponentMeta {
+	name: string;
+	template_dir: string;
+	frontend_dir: string;
+	component_class_id: string;
+}
+
+const args = process.argv.slice(2);
+// get individual args as `--arg value` or `value`
+
+function parse_args(args: string[]): Record<string, string> {
+	const arg_map: Record<string, string> = {};
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg.startsWith("--")) {
+			const name = arg.slice(2);
+			const value = args[i + 1];
+			arg_map[name] = value;
+			i++;
+		}
+	}
+	return arg_map;
+}
+
+const parsed_args = parse_args(args);
+
+async function run(): Promise<void> {
+	if (parsed_args.mode === "build") {
+		await make_build({
+			component_dir: parsed_args["component-directory"],
+			root_dir: parsed_args.root,
+			python_path: parsed_args["python-path"]
+		});
+	} else {
+		const [backend_port, frontend_port] = await find_free_ports(7860, 8860);
+		const options = {
+			component_dir: parsed_args["component-directory"],
+			root_dir: parsed_args.root,
+			frontend_port,
+			backend_port,
+			host: parsed_args.host,
+			...parsed_args
+		};
+		process.env.GRADIO_BACKEND_PORT = backend_port.toString();
+
+		const _process = spawn(
+			parsed_args["gradio-path"],
+			[parsed_args.app, "--watch-dirs", options.component_dir],
+			{
+				shell: true,
+				stdio: "pipe",
+				cwd: process.cwd(),
+				env: {
+					...process.env,
+					GRADIO_SERVER_PORT: backend_port.toString(),
+					PYTHONUNBUFFERED: "true"
+				}
+			}
+		);
+
+		_process.stdout.setEncoding("utf8");
+		_process.stderr.setEncoding("utf8");
+
+		function std_out(mode: "stdout" | "stderr") {
+			return function (data: Buffer): void {
+				const _data = data.toString();
+
+				if (_data.includes("Running on")) {
+					create_server({
+						component_dir: options.component_dir,
+						root_dir: options.root_dir,
+						frontend_port,
+						backend_port,
+						host: options.host,
+						python_path: parsed_args["python-path"]
+					});
+				}
+
+				process[mode].write(_data);
+			};
+		}
+
+		_process.stdout.on("data", std_out("stdout"));
+		_process.stderr.on("data", std_out("stderr"));
+		_process.on("exit", () => kill_process(_process));
+		_process.on("close", () => kill_process(_process));
+		_process.on("disconnect", () => kill_process(_process));
+	}
+}
+
+function kill_process(process: ChildProcess): void {
+	process.kill("SIGKILL");
+}
+
+export { create_server };
+
+run();
+
+export async function find_free_ports(
+	start_port: number,
+	end_port: number
+): Promise<[number, number]> {
+	let found_ports: number[] = [];
+
+	for (let port = start_port; port < end_port; port++) {
+		if (await is_free_port(port)) {
+			found_ports.push(port);
+			if (found_ports.length === 2) {
+				return [found_ports[0], found_ports[1]];
+			}
+		}
+	}
+
+	throw new Error(
+		`Could not find free ports: there were not enough ports available.`
+	);
+}
+
+export function is_free_port(port: number): Promise<boolean> {
+	return new Promise((accept, reject) => {
+		const sock = net.createConnection(port, "127.0.0.1");
+		sock.once("connect", () => {
+			sock.end();
+			accept(false);
+		});
+		sock.once("error", (e) => {
+			sock.destroy();
+			//@ts-ignore
+			if (e.code === "ECONNREFUSED") {
+				accept(true);
+			} else {
+				reject(e);
+			}
+		});
+	});
+}
+
+function is_truthy<T>(value: T | null | undefined | false): value is T {
+	return value !== null && value !== undefined && value !== false;
+}
+
+export function examine_module(
+	component_dir: string,
+	root: string,
+	python_path: string,
+	mode: "build" | "dev"
+): ComponentMeta[] {
+	const _process = spawnSync(
+		python_path,
+		[join(__dirname, "examine.py"), "-m", mode],
+		{
+			cwd: join(component_dir, "backend"),
+			stdio: "pipe"
+		}
+	);
+	const exceptions: string[] = [];
+
+	const components = _process.stdout
+		.toString()
+		.trim()
+		.split("\n")
+		.map((line) => {
+			if (line.startsWith("|EXCEPTION|")) {
+				exceptions.push(line.slice("|EXCEPTION|:".length));
+			}
+			const [name, template_dir, frontend_dir, component_class_id] =
+				line.split("~|~|~|~");
+			if (name && template_dir && frontend_dir && component_class_id) {
+				return {
+					name: name.trim(),
+					template_dir: template_dir.trim(),
+					frontend_dir: frontend_dir.trim(),
+					component_class_id: component_class_id.trim()
+				};
+			}
+			return false;
+		})
+		.filter(is_truthy);
+	if (exceptions.length > 0) {
+		console.info(
+			`While searching for gradio custom component source directories in ${component_dir}, the following exceptions were raised. If dev mode does not work properly please pass the --gradio-path and --python-path CLI arguments so that gradio uses the right executables: ${exceptions.join(
+				"\n"
+			)}`
+		);
+	}
+	return components;
+}

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/preview/src/plugins.ts

@@ -0,0 +1,133 @@
+import type { Plugin, PluginOption } from "vite";
+import { svelte } from "@sveltejs/vite-plugin-svelte";
+import preprocess from "svelte-preprocess";
+import { join } from "path";
+import { type ComponentConfig } from "./dev";
+import type { Preprocessor, PreprocessorGroup } from "svelte/compiler";
+
+const svelte_codes_to_ignore: Record<string, string> = {
+	"reactive-component": "Icon"
+};
+
+const RE_SVELTE_IMPORT =
+	/import\s+([\w*{},\s]+)\s+from\s+['"](svelte|svelte\/internal)['"]/g;
+const RE_BARE_SVELTE_IMPORT = /import ("|')svelte(\/\w+)*("|')(;)*/g;
+export function plugins(config: ComponentConfig): PluginOption[] {
+	const _additional_plugins = config.plugins || [];
+	const _additional_svelte_preprocess = config.svelte?.preprocess || [];
+	const _svelte_extensions = (config.svelte?.extensions || [".svelte"]).map(
+		(ext) => {
+			if (ext.trim().startsWith(".")) {
+				return ext;
+			}
+			return `.${ext.trim()}`;
+		}
+	);
+
+	if (!_svelte_extensions.includes(".svelte")) {
+		_svelte_extensions.push(".svelte");
+	}
+
+	return [
+		svelte({
+			inspector: false,
+			onwarn(warning, handler) {
+				if (
+					svelte_codes_to_ignore.hasOwnProperty(warning.code) &&
+					svelte_codes_to_ignore[warning.code] &&
+					warning.message.includes(svelte_codes_to_ignore[warning.code])
+				) {
+					return;
+				}
+				handler!(warning);
+			},
+			prebundleSvelteLibraries: false,
+			hot: true,
+			compilerOptions: {
+				discloseVersion: false,
+				hydratable: true
+			},
+			extensions: _svelte_extensions,
+			preprocess: [
+				preprocess({
+					typescript: {
+						compilerOptions: {
+							declaration: false,
+							declarationMap: false
+						}
+					}
+				}),
+				...(_additional_svelte_preprocess as PreprocessorGroup[])
+			]
+		}),
+		..._additional_plugins
+	];
+}
+
+interface GradioPluginOptions {
+	mode: "dev" | "build";
+	svelte_dir: string;
+	backend_port?: number;
+	imports?: string;
+}
+
+export function make_gradio_plugin({
+	mode,
+	svelte_dir,
+	backend_port,
+	imports
+}: GradioPluginOptions): Plugin {
+	const v_id = "virtual:component-loader";
+	const resolved_v_id = "\0" + v_id;
+	return {
+		name: "gradio",
+		enforce: "pre",
+		transform(code) {
+			const new_code = code
+				.replace(RE_SVELTE_IMPORT, (str, $1, $2) => {
+					if ($1.trim().startsWith("type")) return str;
+					const identifier = $1.trim().startsWith("* as")
+						? $1.replace("* as", "").trim()
+						: $1.trim();
+					return `const ${identifier.replace(
+						" as ",
+						": "
+					)} = window.__gradio__svelte__internal;`;
+				})
+				.replace(RE_BARE_SVELTE_IMPORT, "");
+			return {
+				code: new_code,
+				map: null
+			};
+		},
+		resolveId(id) {
+			if (id === v_id) {
+				return resolved_v_id;
+			}
+			if (
+				id !== "svelte" &&
+				id !== "svelte/internal" &&
+				id.startsWith("svelte/")
+			) {
+				return join(svelte_dir, "svelte-submodules.js");
+			}
+		},
+		load(id) {
+			if (id === resolved_v_id) {
+				return `export default {};`;
+			}
+		},
+		transformIndexHtml(html) {
+			return mode === "dev"
+				? [
+						{
+							tag: "script",
+							children: `window.__GRADIO_DEV__ = "dev";
+        window.__GRADIO__SERVER_PORT__ = ${backend_port};
+        window.__GRADIO__CC__ = ${imports};`
+						}
+					]
+				: undefined;
+		}
+	};
+}

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/preview/src/register.mjs

@@ -0,0 +1,3 @@
+import { register } from "node:module";
+
+register("./hooks.mjs", import.meta.url);

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/preview/src/svelte-disclose.ts

@@ -0,0 +1,2 @@
+// @ts-ignore
+export * from "svelte/internal/disclose-version";

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/preview/src/svelte-internal.ts

@@ -0,0 +1,2 @@
+//@ts-ignore
+export * from "svelte/internal";

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/preview/src/svelte-submodules.ts

@@ -0,0 +1,5 @@
+export * from "svelte/transition";
+export { spring, tweened } from "svelte/motion";
+export * from "svelte/store";
+export * from "svelte/easing";
+export * from "svelte/animate";

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/preview/src/svelte.ts

@@ -0,0 +1,17 @@
+export {
+	// this proxy is very important, to ensure that we always refer to the same base Component class which is critical for our components to work
+	SvelteComponent as SvelteComponentDev,
+	SvelteComponent,
+	onMount,
+	onDestroy,
+	beforeUpdate,
+	afterUpdate,
+	setContext,
+	getContext,
+	getAllContexts,
+	hasContext,
+	tick,
+	createEventDispatcher,
+	SvelteComponentTyped
+	// @ts-ignore
+} from "svelte/internal";

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/preview/test/test/.gitignore

@@ -0,0 +1,9 @@
+.eggs/
+dist/
+*.pyc
+__pycache__/
+*.py[cod]
+*$py.class
+__tmp/*
+*.pyi
+node_modules

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/preview/test/test/backend/gradio_test/__init__.py

@@ -0,0 +1,4 @@
+
+from .test import Test
+
+__all__ = ['Test']