Add files using upload-large-folder tool

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

@@ -0,0 +1,295 @@
+<script lang="ts">
+	import type { Gradio, SelectData } from "@gradio/utils";
+
+	import { onMount } from "svelte";
+	import {
+		Block,
+		BlockLabel,
+		Empty,
+		IconButton,
+		IconButtonWrapper
+	} from "@gradio/atoms";
+	import { Image, Maximize, Minimize } from "@gradio/icons";
+	import { StatusTracker } from "@gradio/statustracker";
+	import type { LoadingStatus } from "@gradio/statustracker";
+	import { type FileData } from "@gradio/client";
+	import { resolve_wasm_src } from "@gradio/wasm/svelte";
+
+	export let elem_id = "";
+	export let elem_classes: string[] = [];
+	export let visible = true;
+	export let value: {
+		image: FileData;
+		annotations: { image: FileData; label: string }[] | [];
+	} | null = null;
+	let old_value: {
+		image: FileData;
+		annotations: { image: FileData; label: string }[] | [];
+	} | null = null;
+	let _value: {
+		image: FileData;
+		annotations: { image: FileData; label: string }[];
+	} | null = null;
+	export let gradio: Gradio<{
+		change: undefined;
+		select: SelectData;
+	}>;
+	export let label = gradio.i18n("annotated_image.annotated_image");
+	export let show_label = true;
+	export let show_legend = true;
+	export let height: number | undefined;
+	export let width: number | undefined;
+	export let color_map: Record<string, string>;
+	export let container = true;
+	export let scale: number | null = null;
+	export let min_width: number | undefined = undefined;
+	let active: string | null = null;
+	export let loading_status: LoadingStatus;
+	export let show_fullscreen_button = true;
+
+	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();
+		}
+	};
+
+	// `value` can be updated before the Promises from `resolve_wasm_src` are resolved.
+	// In such a case, the resolved values for the old `value` have to be discarded,
+	// This variable `latest_promise` is used to pick up only the values resolved for the latest `value`.
+	let latest_promise: Promise<unknown> | null = null;
+	$: {
+		if (value !== old_value) {
+			old_value = value;
+			gradio.dispatch("change");
+		}
+		if (value) {
+			const normalized_value = {
+				image: value.image as FileData,
+				annotations: value.annotations.map((ann) => ({
+					image: ann.image as FileData,
+					label: ann.label
+				}))
+			};
+			_value = normalized_value;
+
+			// In normal (non-Wasm) Gradio, the `<img>` element should be rendered with the passed values immediately
+			// without waiting for `resolve_wasm_src()` to resolve.
+			// If it waits, a blank image is displayed until the async task finishes
+			// and it leads to undesirable flickering.
+			// So set `_value` immediately above, and update it with the resolved values below later.
+			const image_url_promise = resolve_wasm_src(normalized_value.image.url);
+			const annotation_urls_promise = Promise.all(
+				normalized_value.annotations.map((ann) =>
+					resolve_wasm_src(ann.image.url)
+				)
+			);
+			const current_promise = Promise.all([
+				image_url_promise,
+				annotation_urls_promise
+			]);
+			latest_promise = current_promise;
+			current_promise.then(([image_url, annotation_urls]) => {
+				if (latest_promise !== current_promise) {
+					return;
+				}
+				const async_resolved_value: typeof _value = {
+					image: {
+						...normalized_value.image,
+						url: image_url ?? undefined
+					},
+					annotations: normalized_value.annotations.map((ann, i) => ({
+						...ann,
+						image: {
+							...ann.image,
+							url: annotation_urls[i] ?? undefined
+						}
+					}))
+				};
+				_value = async_resolved_value;
+			});
+		} else {
+			_value = null;
+		}
+	}
+	function handle_mouseover(_label: string): void {
+		active = _label;
+	}
+	function handle_mouseout(): void {
+		active = null;
+	}
+
+	function handle_click(i: number, value: string): void {
+		gradio.dispatch("select", {
+			value: label,
+			index: i
+		});
+	}
+</script>
+
+<Block
+	{visible}
+	{elem_id}
+	{elem_classes}
+	padding={false}
+	{height}
+	{width}
+	allow_overflow={false}
+	{container}
+	{scale}
+	{min_width}
+>
+	<StatusTracker
+		autoscroll={gradio.autoscroll}
+		i18n={gradio.i18n}
+		{...loading_status}
+	/>
+	<BlockLabel
+		{show_label}
+		Icon={Image}
+		label={label || gradio.i18n("image.image")}
+	/>
+
+	<div class="container">
+		{#if _value == null}
+			<Empty size="large" unpadded_box={true}><Image /></Empty>
+		{:else}
+			<div class="image-container" bind:this={image_container}>
+				<IconButtonWrapper>
+					{#if !is_full_screen && show_fullscreen_button}
+						<IconButton
+							Icon={Maximize}
+							label="View in full screen"
+							on:click={toggle_full_screen}
+						/>
+					{/if}
+
+					{#if is_full_screen}
+						<IconButton
+							Icon={Minimize}
+							label="Exit full screen"
+							on:click={toggle_full_screen}
+						/>
+					{/if}
+				</IconButtonWrapper>
+
+				<img
+					class="base-image"
+					class:fit-height={height && !is_full_screen}
+					src={_value ? _value.image.url : null}
+					alt="the base file that is annotated"
+				/>
+				{#each _value ? _value?.annotations : [] as ann, i}
+					<img
+						alt="segmentation mask identifying {label} within the uploaded file"
+						class="mask fit-height"
+						class:fit-height={!is_full_screen}
+						class:active={active == ann.label}
+						class:inactive={active != ann.label && active != null}
+						src={ann.image.url}
+						style={color_map && ann.label in color_map
+							? null
+							: `filter: hue-rotate(${Math.round(
+									(i * 360) / _value?.annotations.length
+								)}deg);`}
+					/>
+				{/each}
+			</div>
+			{#if show_legend && _value}
+				<div class="legend">
+					{#each _value.annotations as ann, i}
+						<button
+							class="legend-item"
+							style="background-color: {color_map && ann.label in color_map
+								? color_map[ann.label] + '88'
+								: `hsla(${Math.round(
+										(i * 360) / _value.annotations.length
+									)}, 100%, 50%, 0.3)`}"
+							on:mouseover={() => handle_mouseover(ann.label)}
+							on:focus={() => handle_mouseover(ann.label)}
+							on:mouseout={() => handle_mouseout()}
+							on:blur={() => handle_mouseout()}
+							on:click={() => handle_click(i, ann.label)}
+						>
+							{ann.label}
+						</button>
+					{/each}
+				</div>
+			{/if}
+		{/if}
+	</div>
+</Block>
+
+<style>
+	.base-image {
+		display: block;
+		width: 100%;
+		height: auto;
+	}
+	.container {
+		display: flex;
+		position: relative;
+		flex-direction: column;
+		justify-content: center;
+		align-items: center;
+		width: var(--size-full);
+		height: var(--size-full);
+	}
+	.image-container {
+		position: relative;
+		top: 0;
+		left: 0;
+		flex-grow: 1;
+		width: 100%;
+		overflow: hidden;
+	}
+	.fit-height {
+		top: 0;
+		left: 0;
+		width: 100%;
+		height: 100%;
+		object-fit: contain;
+	}
+	.mask {
+		opacity: 0.85;
+		transition: all 0.2s ease-in-out;
+		position: absolute;
+	}
+	.image-container:hover .mask {
+		opacity: 0.3;
+	}
+	.mask.active {
+		opacity: 1;
+	}
+	.mask.inactive {
+		opacity: 0;
+	}
+	.legend {
+		display: flex;
+		flex-direction: row;
+		flex-wrap: wrap;
+		align-content: center;
+		justify-content: center;
+		align-items: center;
+		gap: var(--spacing-sm);
+		padding: var(--spacing-sm);
+	}
+	.legend-item {
+		display: flex;
+		flex-direction: row;
+		align-items: center;
+		cursor: pointer;
+		border-radius: var(--radius-sm);
+		padding: var(--spacing-sm);
+	}
+</style>

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

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

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

@@ -0,0 +1,33 @@
+{
+	"name": "@gradio/atoms",
+	"version": "0.9.0",
+	"description": "Gradio UI packages",
+	"type": "module",
+	"main": "src/index.ts",
+	"author": "",
+	"license": "ISC",
+	"dependencies": {
+		"@gradio/icons": "workspace:^",
+		"@gradio/utils": "workspace:^"
+	},
+	"peerDependencies": {
+		"svelte": "^4.0.0"
+	},
+	"exports": {
+		".": {
+			"gradio": "./src/index.ts",
+			"svelte": "./dist/src/index.js",
+			"types": "./dist/src/index.d.ts"
+		},
+		"./package.json": "./package.json"
+	},
+	"main_changeset": true,
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "js/atoms"
+	},
+	"scripts": {
+		"sv-pkg": "svelte-package --input=. --cwd=../../.config/"
+	}
+}

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

@@ -0,0 +1,10 @@
+<script lang="ts">
+	import { Block } from "@gradio/atoms";
+	export let elem_id: string;
+	export let elem_classes: string[];
+	export let visible = true;
+</script>
+
+<Block {elem_id} {elem_classes} {visible} explicit_call>
+	<slot />
+</Block>

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

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

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

@@ -0,0 +1,40 @@
+{
+	"name": "@gradio/checkbox",
+	"version": "0.4.1",
+	"description": "Gradio UI packages",
+	"type": "module",
+	"author": "",
+	"license": "ISC",
+	"private": false,
+	"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"
+		}
+	},
+	"dependencies": {
+		"@gradio/atoms": "workspace:^",
+		"@gradio/statustracker": "workspace:^",
+		"@gradio/utils": "workspace:^"
+	},
+	"devDependencies": {
+		"@gradio/preview": "workspace:^"
+	},
+	"peerDependencies": {
+		"svelte": "^4.0.0"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "js/checkbox"
+	}
+}

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

@@ -0,0 +1,179 @@
+<svelte:options immutable={true} />
+
+<script lang="ts">
+	import type { Gradio, SelectData } from "@gradio/utils";
+	import { Block, BlockTitle } from "@gradio/atoms";
+	import { StatusTracker } from "@gradio/statustracker";
+	import type { LoadingStatus } from "@gradio/statustracker";
+
+	export let gradio: Gradio<{
+		change: never;
+		select: SelectData;
+		input: never;
+		clear_status: LoadingStatus;
+	}>;
+	export let elem_id = "";
+	export let elem_classes: string[] = [];
+	export let visible = true;
+	export let value: (string | number)[] = [];
+	export let choices: [string, string | number][];
+	export let container = true;
+	export let scale: number | null = null;
+	export let min_width: number | undefined = undefined;
+	export let label = gradio.i18n("checkbox.checkbox_group");
+	export let info: string | undefined = undefined;
+	export let show_label = true;
+	export let root: string;
+
+	export let loading_status: LoadingStatus;
+	export let interactive = true;
+	export let old_value = value.slice();
+
+	function toggle_choice(choice: string | number): void {
+		if (value.includes(choice)) {
+			value = value.filter((v) => v !== choice);
+		} else {
+			value = [...value, choice];
+		}
+		gradio.dispatch("input");
+	}
+
+	$: disabled = !interactive;
+
+	$: if (JSON.stringify(old_value) !== JSON.stringify(value)) {
+		old_value = value;
+		gradio.dispatch("change");
+	}
+</script>
+
+<Block
+	{visible}
+	{elem_id}
+	{elem_classes}
+	type="fieldset"
+	{container}
+	{scale}
+	{min_width}
+>
+	<StatusTracker
+		autoscroll={gradio.autoscroll}
+		i18n={gradio.i18n}
+		{...loading_status}
+		on:clear_status={() => gradio.dispatch("clear_status", loading_status)}
+	/>
+	<BlockTitle {root} {show_label} {info}>{label}</BlockTitle>
+
+	<div class="wrap" data-testid="checkbox-group">
+		{#each choices as [display_value, internal_value], i}
+			<label class:disabled class:selected={value.includes(internal_value)}>
+				<input
+					{disabled}
+					on:change={() => toggle_choice(internal_value)}
+					on:input={(evt) =>
+						gradio.dispatch("select", {
+							index: i,
+							value: internal_value,
+							selected: evt.currentTarget.checked
+						})}
+					on:keydown={(event) => {
+						if (event.key === "Enter") {
+							toggle_choice(internal_value);
+							gradio.dispatch("select", {
+								index: i,
+								value: internal_value,
+								selected: !value.includes(internal_value)
+							});
+						}
+					}}
+					checked={value.includes(internal_value)}
+					type="checkbox"
+					name={internal_value?.toString()}
+					title={internal_value?.toString()}
+				/>
+				<span class="ml-2">{display_value}</span>
+			</label>
+		{/each}
+	</div>
+</Block>
+
+<style>
+	.wrap {
+		display: flex;
+		flex-wrap: wrap;
+		gap: var(--checkbox-label-gap);
+	}
+	label {
+		display: flex;
+		align-items: center;
+		transition: var(--button-transition);
+		cursor: pointer;
+		box-shadow: var(--checkbox-label-shadow);
+		border: var(--checkbox-label-border-width) solid
+			var(--checkbox-label-border-color);
+		border-radius: var(--button-small-radius);
+		background: var(--checkbox-label-background-fill);
+		padding: var(--checkbox-label-padding);
+		color: var(--checkbox-label-text-color);
+		font-weight: var(--checkbox-label-text-weight);
+		font-size: var(--checkbox-label-text-size);
+		line-height: var(--line-md);
+	}
+
+	label:hover {
+		background: var(--checkbox-label-background-fill-hover);
+	}
+	label:focus {
+		background: var(--checkbox-label-background-fill-focus);
+	}
+	label.selected {
+		background: var(--checkbox-label-background-fill-selected);
+		color: var(--checkbox-label-text-color-selected);
+		border-color: var(--checkbox-label-border-color-selected);
+	}
+
+	label > * + * {
+		margin-left: var(--size-2);
+	}
+
+	input {
+		--ring-color: transparent;
+		position: relative;
+		box-shadow: var(--checkbox-shadow);
+		border: var(--checkbox-border-width) solid var(--checkbox-border-color);
+		border-radius: var(--checkbox-border-radius);
+		background-color: var(--checkbox-background-color);
+		line-height: var(--line-sm);
+	}
+
+	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:checked:focus {
+		border-color: var(--checkbox-border-color-focus);
+		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:not(:checked):focus {
+		border-color: var(--checkbox-border-color-focus);
+	}
+
+	input[disabled],
+	.disabled {
+		cursor: not-allowed;
+	}
+
+	input:hover {
+		cursor: pointer;
+	}
+</style>

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

@@ -0,0 +1,40 @@
+{
+	"name": "@gradio/checkboxgroup",
+	"version": "0.6.1",
+	"description": "Gradio UI packages",
+	"type": "module",
+	"author": "",
+	"license": "ISC",
+	"private": false,
+	"main_changeset": true,
+	"main": "./Index.svelte",
+	"exports": {
+		".": {
+			"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"
+		},
+		"./package.json": "./package.json"
+	},
+	"dependencies": {
+		"@gradio/atoms": "workspace:^",
+		"@gradio/statustracker": "workspace:^",
+		"@gradio/utils": "workspace:^"
+	},
+	"devDependencies": {
+		"@gradio/preview": "workspace:^"
+	},
+	"peerDependencies": {
+		"svelte": "^4.0.0"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "js/checkboxgroup"
+	}
+}

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

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

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

@@ -0,0 +1,99 @@
+<script context="module" lang="ts">
+	export { default as BaseCode } from "./shared/Code.svelte";
+	export { default as BaseCopy } from "./shared/Copy.svelte";
+	export { default as BaseDownload } from "./shared/Download.svelte";
+	export { default as BaseWidget } from "./shared/Widgets.svelte";
+	export { default as BaseExample } from "./Example.svelte";
+</script>
+
+<script lang="ts">
+	import type { Gradio } from "@gradio/utils";
+	import { afterUpdate } from "svelte";
+
+	import type { LoadingStatus } from "@gradio/statustracker";
+
+	import Code from "./shared/Code.svelte";
+	import Widget from "./shared/Widgets.svelte";
+	import { StatusTracker } from "@gradio/statustracker";
+	import { Block, BlockLabel, Empty } from "@gradio/atoms";
+	import { Code as CodeIcon } from "@gradio/icons";
+
+	export let gradio: Gradio<{
+		change: typeof value;
+		input: never;
+		blur: never;
+		focus: never;
+		clear_status: LoadingStatus;
+	}>;
+	export let value = "";
+	export let value_is_output = false;
+	export let language = "";
+	export let lines = 5;
+	export let max_lines: number | undefined = undefined;
+	export let elem_id = "";
+	export let elem_classes: string[] = [];
+	export let visible = true;
+	export let label = gradio.i18n("code.code");
+	export let show_label = true;
+	export let loading_status: LoadingStatus;
+	export let scale: number | null = null;
+	export let min_width: number | undefined = undefined;
+	export let wrap_lines = false;
+
+	export let interactive: boolean;
+
+	let dark_mode = gradio.theme === "dark";
+
+	function handle_change(): void {
+		gradio.dispatch("change", value);
+		if (!value_is_output) {
+			gradio.dispatch("input");
+		}
+	}
+	afterUpdate(() => {
+		value_is_output = false;
+	});
+	$: value, handle_change();
+</script>
+
+<Block
+	height={max_lines && "fit-content"}
+	variant={"solid"}
+	padding={false}
+	{elem_id}
+	{elem_classes}
+	{visible}
+	{scale}
+	{min_width}
+>
+	<StatusTracker
+		autoscroll={gradio.autoscroll}
+		i18n={gradio.i18n}
+		{...loading_status}
+		on:clear_status={() => gradio.dispatch("clear_status", loading_status)}
+	/>
+
+	{#if show_label}
+		<BlockLabel Icon={CodeIcon} {show_label} {label} float={false} />
+	{/if}
+
+	{#if !value && !interactive}
+		<Empty unpadded_box={true} size="large">
+			<CodeIcon />
+		</Empty>
+	{:else}
+		<Widget {language} {value} />
+
+		<Code
+			bind:value
+			{language}
+			{lines}
+			{max_lines}
+			{dark_mode}
+			{wrap_lines}
+			readonly={!interactive}
+			on:blur={() => gradio.dispatch("blur")}
+			on:focus={() => gradio.dispatch("focus")}
+		/>
+	{/if}
+</Block>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/code/shared/Code.svelte

@@ -0,0 +1,268 @@
+<script lang="ts">
+	import { createEventDispatcher, onMount } from "svelte";
+	import {
+		EditorView,
+		ViewUpdate,
+		keymap,
+		placeholder as placeholderExt
+	} from "@codemirror/view";
+	import { StateEffect, EditorState, type Extension } from "@codemirror/state";
+	import { indentWithTab } from "@codemirror/commands";
+
+	import { basicDark } from "cm6-theme-basic-dark";
+	import { basicLight } from "cm6-theme-basic-light";
+	import { basicSetup } from "./extensions";
+	import { getLanguageExtension } from "./language";
+
+	export let class_names = "";
+	export let value = "";
+	export let dark_mode: boolean;
+	export let basic = true;
+	export let language: string;
+	export let lines = 5;
+	export let max_lines: number | null = null;
+	export let extensions: Extension[] = [];
+	export let use_tab = true;
+	export let readonly = false;
+	export let placeholder: string | HTMLElement | null | undefined = undefined;
+	export let wrap_lines = false;
+
+	const dispatch = createEventDispatcher<{
+		change: string;
+		blur: undefined;
+		focus: undefined;
+	}>();
+	let lang_extension: Extension | undefined;
+	let element: HTMLDivElement;
+	let view: EditorView;
+
+	$: get_lang(language);
+
+	async function get_lang(val: string): Promise<void> {
+		const ext = await getLanguageExtension(val);
+		lang_extension = ext;
+	}
+
+	$: reconfigure(), lang_extension, readonly;
+	$: set_doc(value);
+	$: update_lines();
+
+	function set_doc(new_doc: string): void {
+		if (view && new_doc !== view.state.doc.toString()) {
+			view.dispatch({
+				changes: {
+					from: 0,
+					to: view.state.doc.length,
+					insert: new_doc
+				}
+			});
+		}
+	}
+
+	function update_lines(): void {
+		if (view) {
+			view.requestMeasure({ read: resize });
+		}
+	}
+
+	function create_editor_view(): EditorView {
+		const editorView = new EditorView({
+			parent: element,
+			state: create_editor_state(value)
+		});
+		editorView.dom.addEventListener("focus", handle_focus, true);
+		editorView.dom.addEventListener("blur", handle_blur, true);
+		return editorView;
+	}
+
+	function handle_focus(): void {
+		dispatch("focus");
+	}
+
+	function handle_blur(): void {
+		dispatch("blur");
+	}
+
+	function getGutterLineHeight(_view: EditorView): string | null {
+		let elements = _view.dom.querySelectorAll<HTMLElement>(".cm-gutterElement");
+		if (elements.length === 0) {
+			return null;
+		}
+		for (var i = 0; i < elements.length; i++) {
+			let node = elements[i];
+			let height = getComputedStyle(node)?.height ?? "0px";
+			if (height != "0px") {
+				return height;
+			}
+		}
+		return null;
+	}
+
+	function resize(_view: EditorView): any {
+		let scroller = _view.dom.querySelector<HTMLElement>(".cm-scroller");
+		if (!scroller) {
+			return null;
+		}
+		const lineHeight = getGutterLineHeight(_view);
+		if (!lineHeight) {
+			return null;
+		}
+
+		const minLines = lines == 1 ? 1 : lines + 1;
+		scroller.style.minHeight = `calc(${lineHeight} * ${minLines})`;
+		if (max_lines)
+			scroller.style.maxHeight = `calc(${lineHeight} * ${max_lines + 1})`;
+	}
+
+	function handle_change(vu: ViewUpdate): void {
+		if (vu.docChanged) {
+			const doc = vu.state.doc;
+			const text = doc.toString();
+			value = text;
+			dispatch("change", text);
+		}
+		view.requestMeasure({ read: resize });
+	}
+
+	function get_extensions(): Extension[] {
+		const stateExtensions = [
+			...get_base_extensions(
+				basic,
+				use_tab,
+				placeholder,
+				readonly,
+				lang_extension
+			),
+			FontTheme,
+			...get_theme(),
+			...extensions
+		];
+		return stateExtensions;
+	}
+
+	const FontTheme = EditorView.theme({
+		"&": {
+			fontSize: "var(--text-sm)",
+			backgroundColor: "var(--border-color-secondary)"
+		},
+		".cm-content": {
+			paddingTop: "5px",
+			paddingBottom: "5px",
+			color: "var(--body-text-color)",
+			fontFamily: "var(--font-mono)",
+			minHeight: "100%"
+		},
+		".cm-gutterElement": {
+			marginRight: "var(--spacing-xs)"
+		},
+		".cm-gutters": {
+			marginRight: "1px",
+			borderRight: "1px solid var(--border-color-primary)",
+			backgroundColor: "var(--block-background-fill);",
+			color: "var(--body-text-color-subdued)"
+		},
+		".cm-focused": {
+			outline: "none"
+		},
+		".cm-scroller": {
+			height: "auto"
+		},
+		".cm-cursor": {
+			borderLeftColor: "var(--body-text-color)"
+		}
+	});
+
+	function create_editor_state(_value: string | null | undefined): EditorState {
+		return EditorState.create({
+			doc: _value ?? undefined,
+			extensions: get_extensions()
+		});
+	}
+
+	function get_base_extensions(
+		basic: boolean,
+		use_tab: boolean,
+		placeholder: string | HTMLElement | null | undefined,
+		readonly: boolean,
+		lang: Extension | null | undefined
+	): Extension[] {
+		const extensions: Extension[] = [
+			EditorView.editable.of(!readonly),
+			EditorState.readOnly.of(readonly),
+			EditorView.contentAttributes.of({ "aria-label": "Code input container" })
+		];
+
+		if (basic) {
+			extensions.push(basicSetup);
+		}
+		if (use_tab) {
+			extensions.push(keymap.of([indentWithTab]));
+		}
+		if (placeholder) {
+			extensions.push(placeholderExt(placeholder));
+		}
+		if (lang) {
+			extensions.push(lang);
+		}
+
+		extensions.push(EditorView.updateListener.of(handle_change));
+		if (wrap_lines) {
+			extensions.push(EditorView.lineWrapping);
+		}
+		return extensions;
+	}
+
+	function get_theme(): Extension[] {
+		const extensions: Extension[] = [];
+
+		if (dark_mode) {
+			extensions.push(basicDark);
+		} else {
+			extensions.push(basicLight);
+		}
+		return extensions;
+	}
+
+	function reconfigure(): void {
+		view?.dispatch({
+			effects: StateEffect.reconfigure.of(get_extensions())
+		});
+	}
+
+	onMount(() => {
+		view = create_editor_view();
+		return () => view?.destroy();
+	});
+</script>
+
+<div class="wrap">
+	<div class="codemirror-wrapper {class_names}" bind:this={element} />
+</div>
+
+<style>
+	.wrap {
+		display: flex;
+		flex-direction: column;
+		flex-grow: 1;
+		margin: 0;
+		padding: 0;
+		height: 100%;
+	}
+	.codemirror-wrapper {
+		flex-grow: 1;
+		overflow: auto;
+	}
+
+	:global(.cm-editor) {
+		height: 100%;
+	}
+
+	/* Dunno why this doesn't work through the theme API -- don't remove*/
+	:global(.cm-selectionBackground) {
+		background-color: #b9d2ff30 !important;
+	}
+
+	:global(.cm-focused) {
+		outline: none !important;
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/code/shared/Widgets.svelte

@@ -0,0 +1,13 @@
+<script lang="ts">
+	import Copy from "./Copy.svelte";
+	import Download from "./Download.svelte";
+	import { IconButtonWrapper } from "@gradio/atoms";
+
+	export let value: string;
+	export let language: string;
+</script>
+
+<IconButtonWrapper>
+	<Download {value} {language} />
+	<Copy {value} />
+</IconButtonWrapper>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/code/shared/extensions.ts

@@ -0,0 +1,48 @@
+import type { Extension } from "@codemirror/state";
+import {
+	lineNumbers,
+	highlightSpecialChars,
+	drawSelection,
+	rectangularSelection,
+	crosshairCursor,
+	keymap
+} from "@codemirror/view";
+export { EditorView } from "@codemirror/view";
+import { EditorState } from "@codemirror/state";
+import {
+	foldGutter,
+	indentOnInput,
+	syntaxHighlighting,
+	defaultHighlightStyle,
+	foldKeymap
+} from "@codemirror/language";
+import { history, defaultKeymap, historyKeymap } from "@codemirror/commands";
+import {
+	closeBrackets,
+	closeBracketsKeymap,
+	completionKeymap
+} from "@codemirror/autocomplete";
+import { lintKeymap } from "@codemirror/lint";
+
+export const basicSetup: Extension = /*@__PURE__*/ ((): Extension[] => [
+	lineNumbers(),
+	highlightSpecialChars(),
+	history(),
+	foldGutter(),
+	drawSelection(),
+	EditorState.allowMultipleSelections.of(true),
+	indentOnInput(),
+	syntaxHighlighting(defaultHighlightStyle, { fallback: true }),
+	closeBrackets(),
+	rectangularSelection(),
+	crosshairCursor(),
+
+	keymap.of([
+		...closeBracketsKeymap,
+		...defaultKeymap,
+		...historyKeymap,
+		...foldKeymap,
+		...completionKeymap,
+		...lintKeymap
+	])
+])();

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/code/shared/frontmatter.ts

@@ -0,0 +1,61 @@
+import type {
+	Element,
+	MarkdownExtension,
+	BlockContext,
+	Line
+} from "@lezer/markdown";
+import { parseMixed } from "@lezer/common";
+import { yaml } from "@codemirror/legacy-modes/mode/yaml";
+import { foldInside, foldNodeProp, StreamLanguage } from "@codemirror/language";
+import { styleTags, tags } from "@lezer/highlight";
+
+const frontMatterFence = /^---\s*$/m;
+
+export const frontmatter: MarkdownExtension = {
+	defineNodes: [{ name: "Frontmatter", block: true }, "FrontmatterMark"],
+	props: [
+		styleTags({
+			Frontmatter: [tags.documentMeta, tags.monospace],
+			FrontmatterMark: tags.processingInstruction
+		}),
+		foldNodeProp.add({
+			Frontmatter: foldInside,
+			FrontmatterMark: () => null
+		})
+	],
+	wrap: parseMixed((node) => {
+		const { parser } = StreamLanguage.define(yaml);
+		if (node.type.name === "Frontmatter") {
+			return {
+				parser,
+				overlay: [{ from: node.from + 4, to: node.to - 4 }]
+			};
+		}
+		return null;
+	}),
+	parseBlock: [
+		{
+			name: "Frontmatter",
+			before: "HorizontalRule",
+			parse: (cx: BlockContext, line: Line): boolean => {
+				let end: number | undefined = undefined;
+				const children = new Array<Element>();
+				if (cx.lineStart === 0 && frontMatterFence.test(line.text)) {
+					children.push(cx.elt("FrontmatterMark", 0, 4));
+					while (cx.nextLine()) {
+						if (frontMatterFence.test(line.text)) {
+							end = cx.lineStart + 4;
+							break;
+						}
+					}
+					if (end !== undefined) {
+						children.push(cx.elt("FrontmatterMark", end - 4, end));
+						cx.addElement(cx.elt("Frontmatter", 0, end, children));
+					}
+					return true;
+				}
+				return false;
+			}
+		}
+	]
+};

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/code/shared/language.ts

@@ -0,0 +1,117 @@
+import type { Extension } from "@codemirror/state";
+import { StreamLanguage } from "@codemirror/language";
+import { sql } from "@codemirror/legacy-modes/mode/sql";
+import { _ } from "svelte-i18n";
+
+const possible_langs = [
+	"python",
+	"c",
+	"cpp",
+	"markdown",
+	"json",
+	"html",
+	"css",
+	"javascript",
+	"jinja2",
+	"typescript",
+	"yaml",
+	"dockerfile",
+	"shell",
+	"r",
+	"sql"
+];
+
+const sql_dialects = [
+	"standardSQL",
+	"msSQL",
+	"mySQL",
+	"mariaDB",
+	"sqlite",
+	"cassandra",
+	"plSQL",
+	"hive",
+	"pgSQL",
+	"gql",
+	"gpSQL",
+	"sparkSQL",
+	"esper"
+] as const;
+
+const lang_map: Record<string, (() => Promise<Extension>) | undefined> = {
+	python: () => import("@codemirror/lang-python").then((m) => m.python()),
+	c: () =>
+		import("@codemirror/legacy-modes/mode/clike").then((m) =>
+			StreamLanguage.define(m.c)
+		),
+	cpp: () =>
+		import("@codemirror/legacy-modes/mode/clike").then((m) =>
+			StreamLanguage.define(m.cpp)
+		),
+	markdown: async () => {
+		const [md, frontmatter] = await Promise.all([
+			import("@codemirror/lang-markdown"),
+			import("./frontmatter")
+		]);
+		return md.markdown({ extensions: [frontmatter.frontmatter] });
+	},
+	json: () => import("@codemirror/lang-json").then((m) => m.json()),
+	html: () => import("@codemirror/lang-html").then((m) => m.html()),
+	css: () => import("@codemirror/lang-css").then((m) => m.css()),
+	javascript: () =>
+		import("@codemirror/lang-javascript").then((m) => m.javascript()),
+	jinja2: () =>
+		import("@codemirror/legacy-modes/mode/jinja2").then((m) =>
+			StreamLanguage.define(m.jinja2)
+		),
+	typescript: () =>
+		import("@codemirror/lang-javascript").then((m) =>
+			m.javascript({ typescript: true })
+		),
+	yaml: () =>
+		import("@codemirror/legacy-modes/mode/yaml").then((m) =>
+			StreamLanguage.define(m.yaml)
+		),
+	dockerfile: () =>
+		import("@codemirror/legacy-modes/mode/dockerfile").then((m) =>
+			StreamLanguage.define(m.dockerFile)
+		),
+	shell: () =>
+		import("@codemirror/legacy-modes/mode/shell").then((m) =>
+			StreamLanguage.define(m.shell)
+		),
+	r: () =>
+		import("@codemirror/legacy-modes/mode/r").then((m) =>
+			StreamLanguage.define(m.r)
+		),
+	sql: () =>
+		import("@codemirror/legacy-modes/mode/sql").then((m) =>
+			StreamLanguage.define(m.standardSQL)
+		),
+	...Object.fromEntries(
+		sql_dialects.map((dialect) => [
+			"sql-" + dialect,
+			() =>
+				import("@codemirror/legacy-modes/mode/sql").then((m) =>
+					StreamLanguage.define(m[dialect])
+				)
+		])
+	)
+} as const;
+
+const alias_map: Record<string, string> = {
+	py: "python",
+	md: "markdown",
+	js: "javascript",
+	ts: "typescript",
+	sh: "shell"
+};
+
+export async function getLanguageExtension(
+	lang: string
+): Promise<Extension | undefined> {
+	const _lang = lang_map[lang] || lang_map[alias_map[lang]] || undefined;
+	if (_lang) {
+		return _lang();
+	}
+	return undefined;
+}

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

@@ -0,0 +1,81 @@
+<script lang="ts" context="module">
+	export { default as BaseJSON } from "./shared/JSON.svelte";
+</script>
+
+<script lang="ts">
+	import type { Gradio } from "@gradio/utils";
+	import JSON from "./shared/JSON.svelte";
+	import { Block, BlockLabel } from "@gradio/atoms";
+	import { JSON as JSONIcon } from "@gradio/icons";
+
+	import { StatusTracker } from "@gradio/statustracker";
+	import type { LoadingStatus } from "@gradio/statustracker";
+
+	export let elem_id = "";
+	export let elem_classes: string[] = [];
+	export let visible = true;
+	export let value: any;
+	let old_value: any;
+	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 gradio: Gradio<{
+		change: never;
+		clear_status: LoadingStatus;
+	}>;
+	export let open = false;
+	export let theme_mode: "system" | "light" | "dark";
+	export let show_indices: boolean;
+	export let height: number | string | undefined;
+	export let min_height: number | string | undefined;
+	export let max_height: number | string | undefined;
+
+	$: {
+		if (value !== old_value) {
+			old_value = value;
+			gradio.dispatch("change");
+		}
+	}
+
+	let label_height = 0;
+</script>
+
+<Block
+	{visible}
+	test_id="json"
+	{elem_id}
+	{elem_classes}
+	{container}
+	{scale}
+	{min_width}
+	padding={false}
+	allow_overflow={true}
+	overflow_behavior="auto"
+	{height}
+	{min_height}
+	{max_height}
+>
+	<div bind:clientHeight={label_height}>
+		{#if label}
+			<BlockLabel
+				Icon={JSONIcon}
+				{show_label}
+				{label}
+				float={false}
+				disable={container === false}
+			/>
+		{/if}
+	</div>
+
+	<StatusTracker
+		autoscroll={gradio.autoscroll}
+		i18n={gradio.i18n}
+		{...loading_status}
+		on:clear_status={() => gradio.dispatch("clear_status", loading_status)}
+	/>
+
+	<JSON {value} {open} {theme_mode} {show_indices} {label_height} />
+</Block>

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

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

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/json/shared/JSON.svelte

@@ -0,0 +1,99 @@
+<script lang="ts">
+	import { onDestroy } from "svelte";
+	import { JSON as JSONIcon } from "@gradio/icons";
+	import { Empty, IconButtonWrapper, IconButton } from "@gradio/atoms";
+	import JSONNode from "./JSONNode.svelte";
+	import { Copy, Check } from "@gradio/icons";
+
+	export let value: any = {};
+	export let open = false;
+	export let theme_mode: "system" | "light" | "dark" = "system";
+	export let show_indices = false;
+	export let label_height: number;
+
+	$: json_max_height = `calc(100% - ${label_height}px)`;
+
+	let copied = false;
+	let timer: NodeJS.Timeout;
+
+	function copy_feedback(): void {
+		copied = true;
+		if (timer) clearTimeout(timer);
+		timer = setTimeout(() => {
+			copied = false;
+		}, 1000);
+	}
+
+	async function handle_copy(): Promise<void> {
+		if ("clipboard" in navigator) {
+			await navigator.clipboard.writeText(JSON.stringify(value, null, 2));
+			copy_feedback();
+		}
+	}
+
+	function is_empty(obj: object): boolean {
+		return (
+			obj &&
+			Object.keys(obj).length === 0 &&
+			Object.getPrototypeOf(obj) === Object.prototype &&
+			JSON.stringify(obj) === JSON.stringify({})
+		);
+	}
+
+	onDestroy(() => {
+		if (timer) clearTimeout(timer);
+	});
+</script>
+
+{#if value && value !== '""' && !is_empty(value)}
+	<IconButtonWrapper>
+		<IconButton
+			show_label={false}
+			label={copied ? "Copied" : "Copy"}
+			Icon={copied ? Check : Copy}
+			on:click={() => handle_copy()}
+		/>
+	</IconButtonWrapper>
+	<div class="json-holder" style:max-height={json_max_height}>
+		<JSONNode
+			{value}
+			depth={0}
+			is_root={true}
+			{open}
+			{theme_mode}
+			{show_indices}
+		/>
+	</div>
+{:else}
+	<div class="empty-wrapper">
+		<Empty>
+			<JSONIcon />
+		</Empty>
+	</div>
+{/if}
+
+<style>
+	:global(.copied svg) {
+		animation: fade ease 300ms;
+		animation-fill-mode: forwards;
+	}
+
+	@keyframes fade {
+		0% {
+			opacity: 0;
+		}
+		100% {
+			opacity: 1;
+		}
+	}
+
+	.json-holder {
+		padding: var(--size-2);
+		overflow-y: auto;
+	}
+
+	.empty-wrapper {
+		min-height: calc(var(--size-32) - 20px);
+		height: 100%;
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/json/shared/JSONNode.svelte

@@ -0,0 +1,273 @@
+<script lang="ts">
+	import { onMount, createEventDispatcher, tick, afterUpdate } from "svelte";
+
+	export let value: any;
+	export let depth = 0;
+	export let is_root = false;
+	export let is_last_item = true;
+	export let key: string | number | null = null;
+	export let open = false;
+	export let theme_mode: "system" | "light" | "dark" = "system";
+	export let show_indices = false;
+
+	const dispatch = createEventDispatcher();
+	let root_element: HTMLElement;
+	let collapsed = open ? false : depth >= 3;
+	let child_nodes: any[] = [];
+
+	function is_collapsible(val: any): boolean {
+		return val !== null && (typeof val === "object" || Array.isArray(val));
+	}
+
+	async function toggle_collapse(): Promise<void> {
+		collapsed = !collapsed;
+		await tick();
+		dispatch("toggle", { collapsed, depth });
+	}
+
+	function get_collapsed_preview(val: any): string {
+		if (Array.isArray(val)) return `Array(${val.length})`;
+		if (typeof val === "object" && val !== null)
+			return `Object(${Object.keys(val).length})`;
+		return String(val);
+	}
+
+	$: if (is_collapsible(value)) {
+		child_nodes = Object.entries(value);
+	} else {
+		child_nodes = [];
+	}
+	$: if (is_root && root_element) {
+		updateLineNumbers();
+	}
+
+	function updateLineNumbers(): void {
+		const lines = root_element.querySelectorAll(".line");
+		lines.forEach((line, index) => {
+			const line_number = line.querySelector(".line-number");
+			if (line_number) {
+				line_number.setAttribute("data-pseudo-content", (index + 1).toString());
+				line_number?.setAttribute(
+					"aria-roledescription",
+					`Line number ${index + 1}`
+				);
+				line_number?.setAttribute("title", `Line number ${index + 1}`);
+			}
+		});
+	}
+
+	onMount(() => {
+		if (is_root) {
+			updateLineNumbers();
+		}
+	});
+
+	afterUpdate(() => {
+		if (is_root) {
+			updateLineNumbers();
+		}
+	});
+</script>
+
+<div
+	class="json-node"
+	class:root={is_root}
+	class:dark-mode={theme_mode === "dark"}
+	bind:this={root_element}
+	on:toggle
+	style="--depth: {depth};"
+>
+	<div class="line" class:collapsed>
+		<span class="line-number"></span>
+		<span class="content">
+			{#if is_collapsible(value)}
+				<button
+					data-pseudo-content={collapsed ? "▶" : "▼"}
+					aria-label={collapsed ? "Expand" : "Collapse"}
+					class="toggle"
+					on:click={toggle_collapse}
+				/>
+			{/if}
+			{#if key !== null}
+				<span class="key">"{key}"</span><span class="punctuation colon"
+					>:
+				</span>
+			{/if}
+			{#if is_collapsible(value)}
+				<span
+					class="punctuation bracket"
+					class:square-bracket={Array.isArray(value)}
+					>{Array.isArray(value) ? "[" : "{"}</span
+				>
+				{#if collapsed}
+					<button on:click={toggle_collapse} class="preview">
+						{get_collapsed_preview(value)}
+					</button>
+					<span
+						class="punctuation bracket"
+						class:square-bracket={Array.isArray(value)}
+						>{Array.isArray(value) ? "]" : "}"}</span
+					>
+				{/if}
+			{:else if typeof value === "string"}
+				<span class="value string">"{value}"</span>
+			{:else if typeof value === "number"}
+				<span class="value number">{value}</span>
+			{:else if typeof value === "boolean"}
+				<span class="value bool">{value.toString()}</span>
+			{:else if value === null}
+				<span class="value null">null</span>
+			{:else}
+				<span>{value}</span>
+			{/if}
+			{#if !is_last_item && (!is_collapsible(value) || collapsed)}
+				<span class="punctuation">,</span>
+			{/if}
+		</span>
+	</div>
+
+	{#if is_collapsible(value)}
+		<div class="children" class:hidden={collapsed}>
+			{#each child_nodes as [subKey, subVal], i}
+				<svelte:self
+					value={subVal}
+					depth={depth + 1}
+					is_last_item={i === child_nodes.length - 1}
+					key={subKey}
+					{open}
+					{theme_mode}
+					{show_indices}
+					on:toggle
+				/>
+			{/each}
+			<div class="line">
+				<span class="line-number"></span>
+				<span class="content">
+					<span
+						class="punctuation bracket"
+						class:square-bracket={Array.isArray(value)}
+						>{Array.isArray(value) ? "]" : "}"}</span
+					>
+					{#if !is_last_item}<span class="punctuation">,</span>{/if}
+				</span>
+			</div>
+		</div>
+	{/if}
+</div>
+
+<style>
+	.json-node {
+		font-family: var(--font-mono);
+		--text-color: #d18770;
+		--key-color: var(--text-color);
+		--string-color: #ce9178;
+		--number-color: #719fad;
+
+		--bracket-color: #5d8585;
+		--square-bracket-color: #be6069;
+		--punctuation-color: #8fbcbb;
+		--line-number-color: #6a737d;
+		--separator-color: var(--line-number-color);
+	}
+	.json-node.dark-mode {
+		--bracket-color: #7eb4b3;
+		--number-color: #638d9a;
+	}
+	.json-node.root {
+		position: relative;
+		padding-left: var(--size-14);
+	}
+	.json-node.root::before {
+		content: "";
+		position: absolute;
+		top: 0;
+		bottom: 0;
+		left: var(--size-11);
+		width: 1px;
+		background-color: var(--separator-color);
+	}
+	.line {
+		display: flex;
+		align-items: flex-start;
+		padding: 0;
+		margin: 0;
+		line-height: var(--line-md);
+	}
+	.line-number {
+		position: absolute;
+		left: 0;
+		width: calc(var(--size-7));
+		text-align: right;
+		color: var(--line-number-color);
+		user-select: none;
+		text-overflow: ellipsis;
+		text-overflow: ellipsis;
+		direction: rtl;
+		overflow: hidden;
+	}
+	.content {
+		flex: 1;
+		display: flex;
+		align-items: center;
+		padding-left: calc(var(--depth) * var(--size-2));
+		flex-wrap: wrap;
+	}
+	.children {
+		padding-left: var(--size-4);
+	}
+	.children.hidden {
+		display: none;
+	}
+	.key {
+		color: var(--key-color);
+	}
+	.string {
+		color: var(--string-color);
+	}
+	.number {
+		color: var(--number-color);
+	}
+	.bool {
+		color: var(--text-color);
+	}
+	.null {
+		color: var(--text-color);
+	}
+	.value {
+		margin-left: var(--spacing-md);
+	}
+	.punctuation {
+		color: var(--punctuation-color);
+	}
+	.bracket {
+		margin-left: var(--spacing-sm);
+		color: var(--bracket-color);
+	}
+	.square-bracket {
+		margin-left: var(--spacing-sm);
+		color: var(--square-bracket-color);
+	}
+	.toggle,
+	.preview {
+		background: none;
+		border: none;
+		color: inherit;
+		cursor: pointer;
+		padding: 0;
+		margin: 0;
+	}
+	.toggle {
+		user-select: none;
+		margin-right: var(--spacing-md);
+	}
+	.preview {
+		margin: 0 var(--spacing-sm) 0 var(--spacing-lg);
+	}
+	.preview:hover {
+		text-decoration: underline;
+	}
+
+	:global([data-pseudo-content])::before {
+		content: attr(data-pseudo-content);
+	}
+</style>

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

@@ -0,0 +1,113 @@
+<svelte:options accessors={true} />
+
+<script context="module" lang="ts">
+	export { default as BaseMultimodalTextbox } from "./shared/MultimodalTextbox.svelte";
+	export { default as BaseExample } from "./Example.svelte";
+</script>
+
+<script lang="ts">
+	import type { Gradio, SelectData } from "@gradio/utils";
+	import MultimodalTextbox from "./shared/MultimodalTextbox.svelte";
+	import { Block } from "@gradio/atoms";
+	import { StatusTracker } from "@gradio/statustracker";
+	import type { LoadingStatus } from "@gradio/statustracker";
+	import type { FileData } from "@gradio/client";
+
+	export let gradio: Gradio<{
+		change: typeof value;
+		submit: never;
+		stop: never;
+		blur: never;
+		select: SelectData;
+		input: never;
+		focus: never;
+		error: string;
+		clear_status: LoadingStatus;
+	}>;
+	export let elem_id = "";
+	export let elem_classes: string[] = [];
+	export let visible = true;
+	export let value: { text: string; files: FileData[] } = {
+		text: "",
+		files: []
+	};
+	export let file_types: string[] | null = null;
+	export let lines: number;
+	export let placeholder = "";
+	export let label = "MultimodalTextbox";
+	export let info: string | undefined = undefined;
+	export let show_label: boolean;
+	export let max_lines: number;
+	export let container = true;
+	export let scale: number | null = null;
+	export let min_width: number | undefined = undefined;
+	export let submit_btn: string | boolean | null = null;
+	export let stop_btn: string | boolean | null = null;
+	export let loading_status: LoadingStatus | undefined = undefined;
+	export let value_is_output = false;
+	export let rtl = false;
+	export let text_align: "left" | "right" | undefined = undefined;
+	export let autofocus = false;
+	export let autoscroll = true;
+	export let interactive: boolean;
+	export let root: string;
+	export let file_count: "single" | "multiple" | "directory";
+
+	let dragging: boolean;
+</script>
+
+<Block
+	{visible}
+	{elem_id}
+	elem_classes={[...elem_classes, "multimodal-textbox"]}
+	{scale}
+	{min_width}
+	allow_overflow={false}
+	padding={container}
+	border_mode={dragging ? "focus" : "base"}
+>
+	{#if loading_status}
+		<StatusTracker
+			autoscroll={gradio.autoscroll}
+			i18n={gradio.i18n}
+			{...loading_status}
+			on:clear_status={() => gradio.dispatch("clear_status", loading_status)}
+		/>
+	{/if}
+
+	<MultimodalTextbox
+		bind:value
+		bind:value_is_output
+		bind:dragging
+		{file_types}
+		{root}
+		{label}
+		{info}
+		{show_label}
+		{lines}
+		{rtl}
+		{text_align}
+		max_lines={!max_lines ? lines + 1 : max_lines}
+		{placeholder}
+		{submit_btn}
+		{stop_btn}
+		{autofocus}
+		{container}
+		{autoscroll}
+		{file_count}
+		max_file_size={gradio.max_file_size}
+		on:change={() => gradio.dispatch("change", value)}
+		on:input={() => gradio.dispatch("input")}
+		on:submit={() => gradio.dispatch("submit")}
+		on:stop={() => gradio.dispatch("stop")}
+		on:blur={() => gradio.dispatch("blur")}
+		on:select={(e) => gradio.dispatch("select", e.detail)}
+		on:focus={() => gradio.dispatch("focus")}
+		on:error={({ detail }) => {
+			gradio.dispatch("error", detail);
+		}}
+		disabled={!interactive}
+		upload={(...args) => gradio.client.upload(...args)}
+		stream_handler={(...args) => gradio.client.stream(...args)}
+	/>
+</Block>

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

@@ -0,0 +1,60 @@
+import { tick } from "svelte";
+
+interface Value {
+	lines: number;
+	max_lines: number;
+	text: string;
+}
+
+export async function resize(
+	target: HTMLTextAreaElement | HTMLInputElement,
+	lines: number,
+	max_lines: number
+): Promise<void> {
+	await tick();
+	if (lines === max_lines) return;
+
+	const computed_styles = window.getComputedStyle(target);
+	const padding_top = parseFloat(computed_styles.paddingTop);
+	const padding_bottom = parseFloat(computed_styles.paddingBottom);
+	const line_height = parseFloat(computed_styles.lineHeight);
+
+	let max =
+		max_lines === undefined
+			? false
+			: padding_top + padding_bottom + line_height * max_lines;
+	let min = padding_top + padding_bottom + lines * line_height;
+
+	target.style.height = "1px";
+
+	let scroll_height;
+	if (max && target.scrollHeight > max) {
+		scroll_height = max;
+	} else if (target.scrollHeight < min) {
+		scroll_height = min;
+	} else {
+		scroll_height = target.scrollHeight;
+	}
+
+	target.style.height = `${scroll_height}px`;
+}
+
+export function text_area_resize(
+	_el: HTMLTextAreaElement,
+	_value: Value
+): any | undefined {
+	if (_value.lines === _value.max_lines) return;
+	_el.style.overflowY = "scroll";
+
+	function handle_input(event: Event): void {
+		resize(event.target as HTMLTextAreaElement, _value.lines, _value.max_lines);
+	}
+	_el.addEventListener("input", handle_input);
+
+	if (!_value.text.trim()) return;
+	resize(_el, _value.lines, _value.max_lines);
+
+	return {
+		destroy: () => _el.removeEventListener("input", handle_input)
+	};
+}

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/paramviewer/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
+>
+	<pre>{JSON.stringify(value, null, 2)}</pre>
+</div>
+
+<style>
+	.gallery {
+		padding: var(--size-1) var(--size-2);
+	}
+</style>

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

@@ -0,0 +1,17 @@
+<script lang="ts">
+	import ParamViewer from "./ParamViewer.svelte";
+
+	export let value: Record<
+		string,
+		{
+			type: string;
+			description: string;
+			default: string;
+		}
+	>;
+
+	export let linkify: string[] = [];
+	export let header: string | null = null;
+</script>
+
+<ParamViewer docs={value} {linkify} {header} />

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/paramviewer/ParamViewer.svelte

@@ -0,0 +1,259 @@
+<script lang="ts">
+	import "./prism.css";
+
+	import Prism from "prismjs";
+	import "prismjs/components/prism-python";
+	import "prismjs/components/prism-typescript";
+
+	interface Param {
+		type: string | null;
+		description: string;
+		default: string | null;
+		name?: string;
+	}
+
+	export let docs: Record<string, Param>;
+	export let lang: "python" | "typescript" = "python";
+	export let linkify: string[] = [];
+	export let header: string | null;
+
+	let component_root: HTMLElement;
+	let _docs: Param[];
+	let all_open = false;
+
+	$: _docs = highlight_code(docs, lang);
+
+	function highlight(code: string, lang: "python" | "typescript"): string {
+		let highlighted = Prism.highlight(code, Prism.languages[lang], lang);
+
+		for (const link of linkify) {
+			highlighted = highlighted.replace(
+				new RegExp(link, "g"),
+				`<a href="#h-${link.toLocaleLowerCase()}">${link}</a>`
+			);
+		}
+
+		return highlighted;
+	}
+
+	function highlight_code(
+		_docs: typeof docs,
+		lang: "python" | "typescript"
+	): Param[] {
+		if (!_docs) {
+			return [];
+		}
+		return Object.entries(_docs).map(
+			([name, { type, description, default: _default }]) => {
+				let highlighted_type = type ? highlight(type, lang) : null;
+
+				return {
+					name: name,
+					type: highlighted_type,
+					description: description,
+					default: _default ? highlight(_default, lang) : null
+				};
+			}
+		);
+	}
+
+	function toggle_all(): void {
+		all_open = !all_open;
+		const details = component_root.querySelectorAll(".param");
+		details.forEach((detail) => {
+			if (detail instanceof HTMLDetailsElement) {
+				detail.open = all_open;
+			}
+		});
+	}
+</script>
+
+<div class="wrap" bind:this={component_root}>
+	{#if header !== null}
+		<div class="header">
+			<span class="title">{header}</span>
+			<button
+				class="toggle-all"
+				on:click={toggle_all}
+				title={all_open ? "Close All" : "Open All"}
+			>
+				▼
+			</button>
+		</div>
+	{/if}
+	{#if _docs}
+		{#each _docs as { type, description, default: _default, name } (name)}
+			<details class="param md">
+				<summary class="type">
+					<pre class="language-{lang}"><code
+							>{name}{#if type}: {@html type}{/if}</code
+						></pre>
+				</summary>
+				{#if _default}
+					<div class="default" class:last={!description}>
+						<span style:padding-right={"4px"}>default</span>
+						<code>= {@html _default}</code>
+					</div>
+				{/if}
+				{#if description}
+					<div class="description"><p>{description}</p></div>
+				{/if}
+			</details>
+		{/each}
+	{/if}
+</div>
+
+<style>
+	.header {
+		display: flex;
+		justify-content: space-between;
+		align-items: center;
+		padding: 0.7rem 1rem;
+		border-bottom: 1px solid var(--table-border-color);
+	}
+
+	.title {
+		font-size: var(--scale-0);
+		font-weight: 600;
+		color: var(--body-text-color);
+	}
+
+	.toggle-all {
+		background: none;
+		border: none;
+		cursor: pointer;
+		padding: 0;
+		color: var(--body-text-color);
+		font-size: 0.7em;
+		line-height: 1;
+		opacity: 0.7;
+		transition:
+			opacity 0.2s ease,
+			transform 0.3s ease;
+	}
+
+	.toggle-all:hover {
+		opacity: 1;
+	}
+
+	:global(.wrap[data-all-open="true"]) .toggle-all {
+		transform: rotate(180deg);
+	}
+
+	.default :global(pre),
+	.default :global(.highlight) {
+		display: inline-block;
+	}
+
+	.wrap :global(pre),
+	.wrap :global(.highlight) {
+		margin: 0 !important;
+		background: transparent !important;
+		font-family: var(--font-mono);
+		font-weight: 400;
+		padding: 0 !important;
+	}
+
+	.wrap :global(pre a) {
+		color: var(--link-text-color-hover);
+		text-decoration: underline;
+	}
+
+	.wrap :global(pre a:hover) {
+		color: var(--link-text-color-hover);
+	}
+
+	.default > span {
+		text-transform: uppercase;
+		font-size: 0.7rem;
+		font-weight: 600;
+	}
+
+	.default > code {
+		border: none;
+	}
+	code {
+		background: none;
+		font-family: var(--font-mono);
+	}
+
+	.wrap {
+		padding: 0rem;
+		border-radius: 5px;
+		border: 1px solid #eee;
+		overflow: hidden;
+		position: relative;
+		margin: 0;
+		box-shadow: var(--block-shadow);
+		border-width: var(--block-border-width);
+		border-color: var(--block-border-color);
+		border-radius: var(--block-radius);
+		width: 100%;
+		line-height: var(--line-sm);
+		color: var(--body-text-color);
+	}
+
+	.type {
+		position: relative;
+		padding: 0.7rem 1rem;
+		background: var(--table-odd-background-fill);
+		border-bottom: 0px solid var(--table-border-color);
+		list-style: none;
+	}
+
+	.type::after {
+		content: "▼";
+		position: absolute;
+		top: 50%;
+		right: 15px;
+		transform: translateY(-50%);
+		transition: transform 0.3s ease;
+		font-size: 0.7em;
+		opacity: 0.7;
+	}
+
+	details[open] .type::after {
+		transform: translateY(-50%) rotate(180deg);
+	}
+
+	.default {
+		padding: 0.2rem 1rem 0.3rem 1rem;
+		border-bottom: 1px solid var(--table-border-color);
+		background: var(--block-background-fill);
+	}
+
+	.default.last {
+		border-bottom: none;
+	}
+
+	.description {
+		padding: 0.7rem 1rem;
+		font-size: var(--scale-00);
+		font-family: var(--font-sans);
+		background: var(--block-background-fill);
+	}
+
+	.param {
+		border-bottom: 1px solid var(--table-border-color);
+	}
+
+	.param:last-child {
+		border-bottom: none;
+	}
+
+	details[open] .type {
+		border-bottom-width: 1px;
+	}
+
+	.param.md code {
+		background: none;
+	}
+
+	details > summary {
+		cursor: pointer;
+	}
+
+	details > summary::-webkit-details-marker {
+		display: none;
+	}
+</style>

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

@@ -0,0 +1,41 @@
+{
+	"name": "@gradio/paramviewer",
+	"version": "0.5.1",
+	"description": "Gradio UI packages",
+	"type": "module",
+	"author": "",
+	"license": "ISC",
+	"private": false,
+	"main_changeset": true,
+	"exports": {
+		".": {
+			"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"
+		},
+		"./package.json": "./package.json"
+	},
+	"dependencies": {
+		"@gradio/atoms": "workspace:^",
+		"@gradio/statustracker": "workspace:^",
+		"@gradio/utils": "workspace:^",
+		"prismjs": "^1.29.0"
+	},
+	"devDependencies": {
+		"@types/prismjs": "^1.26.3",
+		"@gradio/preview": "workspace:^"
+	},
+	"peerDependencies": {
+		"svelte": "^4.0.0"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "js/paramviewer"
+	}
+}

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/paramviewer/prism.css

@@ -0,0 +1,211 @@
+Tables */ table,
+tr,
+td,
+th {
+	margin-top: var(--spacing-sm);
+	margin-bottom: var(--spacing-sm);
+	padding: var(--spacing-xl);
+}
+
+/* .message-wrap :global(pre[class*="language-"]),
+	.message-wrap :global(pre) {
+		border: none;
+		background: none;
+		position: relative;
+		direction: ltr;
+		white-space: no-wrap;
+		overflow-x: auto;
+	}
+	.message-wrap :global(code) {
+	} */
+
+/* .message-wrap :global(div[class*="code_wrap"]) {
+		
+	} */
+
+.md code,
+.md pre {
+	background: none;
+	font-family: var(--font-mono);
+	font-size: var(--text-md);
+
+	text-align: left;
+	white-space: pre;
+	word-spacing: normal;
+	word-break: normal;
+	word-wrap: normal;
+	line-height: 1.5;
+	tab-size: 2;
+
+	hyphens: none;
+}
+
+.md pre[class*="language-"]::-moz-selection,
+.md pre[class*="language-"] ::-moz-selection,
+.md code[class*="language-"]::-moz-selection,
+.md code[class*="language-"] ::-moz-selection {
+}
+
+.md pre[class*="language-"]::selection,
+.md pre[class*="language-"] ::selection,
+.md code[class*="language-"]::selection,
+.md code[class*="language-"] ::selection {
+	text-shadow: none;
+	background: #b3d4fc;
+}
+
+/* Code blocks */
+.md pre {
+	padding: 1em;
+	margin: 0.5em 0;
+	overflow: auto;
+	position: relative;
+	margin-top: var(--spacing-sm);
+	margin-bottom: var(--spacing-sm);
+	box-shadow: none;
+	border: none;
+	border-radius: var(--radius-md);
+	background: var(--code-background-fill);
+	font-family: var(--font-mono);
+	display: block;
+	white-space: pre;
+	border-radius: var(--radius-sm);
+	text-shadow: none;
+	border-radius: var(--radius-sm);
+	/* font-size: 85%; */
+	white-space: nowrap;
+	display: block;
+	white-space: pre;
+}
+
+.prose code {
+}
+.prose pre > code {
+}
+
+/* Inline code */
+.md :not(pre) > code {
+	padding: 0.1em;
+	border-radius: var(--radius-xs);
+	white-space: normal;
+	background: var(--code-background-fill);
+	border: 1px solid var(--panel-border-color);
+	padding: var(--spacing-xxs) var(--spacing-xs);
+}
+
+.md .token.comment,
+.md .token.prolog,
+.md .token.doctype,
+.md .token.cdata {
+	color: slategray;
+}
+
+.md .token.punctuation {
+	color: #999;
+}
+
+.md .token.namespace {
+	opacity: 0.7;
+}
+
+.md .token.property,
+.md .token.tag,
+.md .token.boolean,
+.md .token.number,
+.md .token.constant,
+.md .token.symbol,
+.md .token.deleted {
+	color: #905;
+}
+
+.md .token.selector,
+.md .token.attr-name,
+.md .token.string,
+.md .token.char,
+.md .token.builtin,
+.md .token.inserted {
+	color: #690;
+}
+
+.md .token.atrule,
+.md .token.attr-value,
+.md .token.keyword {
+	color: #07a;
+}
+
+.md .token.function,
+.md .token.class-name {
+	color: #dd4a68;
+}
+
+.md .token.regex,
+.md .token.important,
+.md .token.variable {
+	color: #e90;
+}
+
+.md .token.important,
+.md .token.bold {
+	font-weight: bold;
+}
+.md .token.italic {
+	font-style: italic;
+}
+
+.md .token.entity {
+	cursor: help;
+}
+
+.dark .md .token.comment,
+.dark .md .token.prolog,
+.dark .md .token.cdata {
+	color: hsl(220, 10%, 40%);
+}
+
+.dark .md .token.doctype,
+.dark .md .token.punctuation,
+.dark .md .token.entity {
+	color: hsl(220, 14%, 71%);
+}
+
+.dark .md .token.attr-name,
+.dark .md .token.class-name,
+.dark .md .token.boolean,
+.dark .md .token.constant,
+.dark .md .token.number,
+.dark .md .token.atrule {
+	color: hsl(29, 54%, 61%);
+}
+
+.dark .md .token.keyword {
+	color: hsl(286, 60%, 67%);
+}
+
+.dark .md .token.property,
+.dark .md .token.tag,
+.dark .md .token.symbol,
+.dark .md .token.deleted,
+.dark .md .token.important {
+	color: hsl(355, 65%, 65%);
+}
+
+.dark .md .token.selector,
+.dark .md .token.string,
+.dark .md .token.char,
+.dark .md .token.builtin,
+.dark .md .token.inserted,
+.dark .md .token.regex,
+.dark .md .token.attr-value,
+.dark .md .token.attr-value > .token.punctuation {
+	color: hsl(95, 38%, 62%);
+}
+
+.dark .md .token.variable,
+.dark .md .token.operator,
+.dark .md .token.function {
+	color: hsl(207, 82%, 66%);
+}
+
+.dark .md .token.url {
+	color: hsl(187, 47%, 55%);
+}

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

@@ -0,0 +1,30 @@
+<script context="module" lang="ts">
+	export { default as BaseTabItem } from "./shared/TabItem.svelte";
+</script>
+
+<script lang="ts">
+	import type { Gradio, SelectData } from "@gradio/utils";
+	import TabItem from "./shared/TabItem.svelte";
+
+	export let elem_id = "";
+	export let elem_classes: string[] = [];
+	export let label: string;
+	export let id: string | number;
+	export let gradio: Gradio<{
+		select: SelectData;
+	}>;
+	export let visible = true;
+	export let interactive = true;
+</script>
+
+<TabItem
+	{elem_id}
+	{elem_classes}
+	name={label}
+	{visible}
+	{interactive}
+	{id}
+	on:select={({ detail }) => gradio.dispatch("select", detail)}
+>
+	<slot />
+</TabItem>

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

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

evalkit_tf437/lib/python3.10/site-packages/gradio/_frontend_code/tabitem/shared/TabItem.svelte

@@ -0,0 +1,52 @@
+<script lang="ts">
+	import { getContext, onMount, createEventDispatcher, tick } from "svelte";
+	import { TABS } from "@gradio/tabs";
+	import Column from "@gradio/column";
+	import type { SelectData } from "@gradio/utils";
+
+	export let elem_id = "";
+	export let elem_classes: string[] = [];
+	export let name: string;
+	export let id: string | number | object = {};
+	export let visible: boolean;
+	export let interactive: boolean;
+
+	const dispatch = createEventDispatcher<{ select: SelectData }>();
+
+	const { register_tab, unregister_tab, selected_tab, selected_tab_index } =
+		getContext(TABS) as any;
+
+	let tab_index: number;
+
+	$: tab_index = register_tab({ name, id, elem_id, visible, interactive });
+
+	onMount(() => {
+		return (): void => unregister_tab({ name, id, elem_id });
+	});
+
+	$: $selected_tab_index === tab_index &&
+		tick().then(() => dispatch("select", { value: name, index: tab_index }));
+</script>
+
+<div
+	id={elem_id}
+	class="tabitem {elem_classes.join(' ')}"
+	style:display={$selected_tab === id && visible ? "block" : "none"}
+	role="tabpanel"
+>
+	<Column>
+		<slot />
+	</Column>
+</div>
+
+<style>
+	div {
+		display: flex;
+		position: relative;
+		border: none;
+		border-radius: var(--radius-sm);
+		padding: var(--block-padding);
+		width: 100%;
+		box-sizing: border-box;
+	}
+</style>

evalkit_tf437/lib/python3.10/site-packages/gradio/layouts/accordion.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from gradio_client.documentation import document
+
+from gradio.blocks import BlockContext
+from gradio.component_meta import ComponentMeta
+
+if TYPE_CHECKING:
+    pass
+
+
+@document()
+class Accordion(BlockContext, metaclass=ComponentMeta):
+    """
+    Accordion is a layout element which can be toggled to show/hide the contained content.
+    Example:
+        with gr.Accordion("See Details"):
+            gr.Markdown("lorem ipsum")
+    """
+
+    EVENTS = []
+
+    def __init__(
+        self,
+        label: str | None = None,
+        *,
+        open: bool = True,
+        visible: bool = True,
+        elem_id: str | None = None,
+        elem_classes: list[str] | str | None = None,
+        render: bool = True,
+    ):
+        """
+        Parameters:
+            label: name of accordion section.
+            open: if True, accordion is open by default.
+            elem_id: An optional string that is assigned as the id of this component in the HTML DOM. Can be used for targeting CSS styles.
+            elem_classes: An optional string or list of strings that are assigned as the class of this component in the HTML DOM. Can be used for targeting CSS styles.
+            render: If False, this layout will not be rendered in the Blocks context. Should be used if the intention is to assign event listeners now but render the component later.
+        """
+        self.label = label
+        self.open = open
+        BlockContext.__init__(
+            self,
+            visible=visible,
+            elem_id=elem_id,
+            elem_classes=elem_classes,
+            render=render,
+        )

evalkit_tf437/lib/python3.10/site-packages/gradio/layouts/column.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+import warnings
+from typing import Literal
+
+from gradio_client.documentation import document
+
+from gradio.blocks import BlockContext
+from gradio.component_meta import ComponentMeta
+
+
+@document()
+class Column(BlockContext, metaclass=ComponentMeta):
+    """
+    Column is a layout element within Blocks that renders all children vertically. The widths of columns can be set through the `scale` and `min_width` parameters.
+    If a certain scale results in a column narrower than min_width, the min_width parameter will win.
+    Example:
+        with gr.Blocks() as demo:
+            with gr.Row():
+                with gr.Column(scale=1):
+                    text1 = gr.Textbox()
+                    text2 = gr.Textbox()
+                with gr.Column(scale=4):
+                    btn1 = gr.Button("Button 1")
+                    btn2 = gr.Button("Button 2")
+    Guides: controlling-layout
+    """
+
+    EVENTS = []
+
+    def __init__(
+        self,
+        *,
+        scale: int = 1,
+        min_width: int = 320,
+        variant: Literal["default", "panel", "compact"] = "default",
+        visible: bool = True,
+        elem_id: str | None = None,
+        elem_classes: list[str] | str | None = None,
+        render: bool = True,
+        show_progress: bool = False,
+    ):
+        """
+        Parameters:
+            scale: relative width compared to adjacent Columns. For example, if Column A has scale=2, and Column B has scale=1, A will be twice as wide as B.
+            min_width: minimum pixel width of Column, will wrap if not sufficient screen space to satisfy this value. If a certain scale value results in a column narrower than min_width, the min_width parameter will be respected first.
+            variant: column type, 'default' (no background), 'panel' (gray background color and rounded corners), or 'compact' (rounded corners and no internal gap).
+            visible: If False, column will be hidden.
+            elem_id: An optional string that is assigned as the id of this component in the HTML DOM. Can be used for targeting CSS styles.
+            elem_classes: An optional string or list of strings that are assigned as the class of this component in the HTML DOM. Can be used for targeting CSS styles.
+            render: If False, component will not render be rendered in the Blocks context. Should be used if the intention is to assign event listeners now but render the component later.
+            show_progress: If True, shows progress animation when being updated.
+        """
+        if scale != round(scale):
+            warnings.warn(
+                f"'scale' value should be an integer. Using {scale} will cause issues."
+            )
+
+        self.scale = scale
+        self.min_width = min_width
+        self.variant = variant
+        if variant == "compact":
+            self.allow_expected_parents = False
+        self.show_progress = show_progress
+        BlockContext.__init__(
+            self,
+            visible=visible,
+            elem_id=elem_id,
+            elem_classes=elem_classes,
+            render=render,
+        )

evalkit_tf437/lib/python3.10/site-packages/gradio/layouts/column.pyi

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import warnings
+from typing import Literal
+
+from gradio_client.documentation import document
+
+from gradio.blocks import BlockContext
+from gradio.component_meta import ComponentMeta
+
+from gradio.events import Dependency
+
+@document()
+class Column(BlockContext, metaclass=ComponentMeta):
+    """
+    Column is a layout element within Blocks that renders all children vertically. The widths of columns can be set through the `scale` and `min_width` parameters.
+    If a certain scale results in a column narrower than min_width, the min_width parameter will win.
+    Example:
+        with gr.Blocks() as demo:
+            with gr.Row():
+                with gr.Column(scale=1):
+                    text1 = gr.Textbox()
+                    text2 = gr.Textbox()
+                with gr.Column(scale=4):
+                    btn1 = gr.Button("Button 1")
+                    btn2 = gr.Button("Button 2")
+    Guides: controlling-layout
+    """
+
+    EVENTS = []
+
+    def __init__(
+        self,
+        *,
+        scale: int = 1,
+        min_width: int = 320,
+        variant: Literal["default", "panel", "compact"] = "default",
+        visible: bool = True,
+        elem_id: str | None = None,
+        elem_classes: list[str] | str | None = None,
+        render: bool = True,
+        show_progress: bool = False,
+    ):
+        """
+        Parameters:
+            scale: relative width compared to adjacent Columns. For example, if Column A has scale=2, and Column B has scale=1, A will be twice as wide as B.
+            min_width: minimum pixel width of Column, will wrap if not sufficient screen space to satisfy this value. If a certain scale value results in a column narrower than min_width, the min_width parameter will be respected first.
+            variant: column type, 'default' (no background), 'panel' (gray background color and rounded corners), or 'compact' (rounded corners and no internal gap).
+            visible: If False, column will be hidden.
+            elem_id: An optional string that is assigned as the id of this component in the HTML DOM. Can be used for targeting CSS styles.
+            elem_classes: An optional string or list of strings that are assigned as the class of this component in the HTML DOM. Can be used for targeting CSS styles.
+            render: If False, component will not render be rendered in the Blocks context. Should be used if the intention is to assign event listeners now but render the component later.
+            show_progress: If True, shows progress animation when being updated.
+        """
+        if scale != round(scale):
+            warnings.warn(
+                f"'scale' value should be an integer. Using {scale} will cause issues."
+            )
+
+        self.scale = scale
+        self.min_width = min_width
+        self.variant = variant
+        if variant == "compact":
+            self.allow_expected_parents = False
+        self.show_progress = show_progress
+        BlockContext.__init__(
+            self,
+            visible=visible,
+            elem_id=elem_id,
+            elem_classes=elem_classes,
+            render=render,
+        )
+    from typing import Callable, Literal, Sequence, Any, TYPE_CHECKING
+    from gradio.blocks import Block
+    if TYPE_CHECKING:
+        from gradio.components import Timer

evalkit_tf437/lib/python3.10/site-packages/gradio/layouts/form.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from gradio.blocks import BlockContext, Blocks
+from gradio.component_meta import ComponentMeta
+from gradio.layouts.column import Column
+from gradio.layouts.row import Row
+
+if TYPE_CHECKING:
+    from gradio.blocks import Block
+
+
+class Form(BlockContext, metaclass=ComponentMeta):
+    EVENTS = []
+
+    def __init__(
+        self,
+        *,
+        scale: int = 0,
+        min_width: int = 0,
+        render: bool = True,
+    ):
+        """
+        Parameters:
+            scale: relative width compared to adjacent Columns. For example, if Column A has scale=2, and Column B has scale=1, A will be twice as wide as B.
+            min_width: minimum pixel width of Column, will wrap if not sufficient screen space to satisfy this value. If a certain scale value results in a column narrower than min_width, the min_width parameter will be respected first.
+            render: If False, this layout will not be rendered in the Blocks context. Should be used if the intention is to assign event listeners now but render the component later.
+        """
+        self.scale = scale
+        self.min_width = min_width
+        BlockContext.__init__(
+            self,
+            render=render,
+        )
+
+    def add_child(self, child: Block):
+        if isinstance(self.parent, Row):
+            scale = getattr(child, "scale", None)
+            self.scale += 1 if scale is None else scale
+            self.min_width += getattr(child, "min_width", 0) or 0
+        elif (
+            isinstance(self.parent, Column)
+            and isinstance(self.parent.parent, Row)
+            and self.parent.parent.equal_height
+        ):
+            scale = getattr(child, "scale", None)
+            self.scale += 1 if scale is None else scale
+        elif isinstance(self.parent, Blocks) and self.parent.fill_height:
+            scale = getattr(child, "scale", None)
+            self.scale += 0 if scale is None else scale
+        BlockContext.add_child(self, child)

evalkit_tf437/lib/python3.10/site-packages/gradio/layouts/group.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from gradio_client.documentation import document
+
+from gradio.blocks import BlockContext
+from gradio.component_meta import ComponentMeta
+
+
+@document()
+class Group(BlockContext, metaclass=ComponentMeta):
+    """
+    Group is a layout element within Blocks which groups together children so that
+    they do not have any padding or margin between them.
+    Example:
+        with gr.Group():
+            gr.Textbox(label="First")
+            gr.Textbox(label="Last")
+    """
+
+    EVENTS = []
+
+    def __init__(
+        self,
+        *,
+        visible: bool = True,
+        elem_id: str | None = None,
+        elem_classes: list[str] | str | None = None,
+        render: bool = True,
+    ):
+        """
+        Parameters:
+            visible: If False, group will be hidden.
+            elem_id: An optional string that is assigned as the id of this component in the HTML DOM. Can be used for targeting CSS styles.
+            elem_classes: An optional string or list of strings that are assigned as the class of this component in the HTML DOM. Can be used for targeting CSS styles.
+            render: If False, this layout will not be rendered in the Blocks context. Should be used if the intention is to assign event listeners now but render the component later.
+        """
+        BlockContext.__init__(
+            self,
+            visible=visible,
+            elem_id=elem_id,
+            elem_classes=elem_classes,
+            render=render,
+        )

evalkit_tf437/lib/python3.10/site-packages/gradio/layouts/row.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from gradio_client.documentation import document
+
+from gradio.blocks import BlockContext
+from gradio.component_meta import ComponentMeta
+
+
+@document()
+class Row(BlockContext, metaclass=ComponentMeta):
+    """
+    Row is a layout element within Blocks that renders all children horizontally.
+    Example:
+        with gr.Blocks() as demo:
+            with gr.Row():
+                gr.Image("lion.jpg", scale=2)
+                gr.Image("tiger.jpg", scale=1)
+        demo.launch()
+    Guides: controlling-layout
+    """
+
+    EVENTS = []
+
+    def __init__(
+        self,
+        *,
+        variant: Literal["default", "panel", "compact"] = "default",
+        visible: bool = True,
+        elem_id: str | None = None,
+        elem_classes: list[str] | str | None = None,
+        render: bool = True,
+        height: int | str | None = None,
+        max_height: int | str | None = None,
+        min_height: int | str | None = None,
+        equal_height: bool = False,
+        show_progress: bool = False,
+    ):
+        """
+        Parameters:
+            variant: row type, 'default' (no background), 'panel' (gray background color and rounded corners), or 'compact' (rounded corners and no internal gap).
+            visible: If False, row will be hidden.
+            elem_id: An optional string that is assigned as the id of this component in the HTML DOM. Can be used for targeting CSS styles.
+            elem_classes: An optional string or list of strings that are assigned as the class of this component in the HTML DOM. Can be used for targeting CSS styles.
+            render: If False, this layout will not be rendered in the Blocks context. Should be used if the intention is to assign event listeners now but render the component later.
+            height: The height of the row, specified in pixels if a number is passed, or in CSS units if a string is passed. If content exceeds the height, the row will scroll vertically. If not set, the row will expand to fit the content.
+            max_height: The maximum height of the row, specified in pixels if a number is passed, or in CSS units if a string is passed. If content exceeds the height, the row will scroll vertically. If content is shorter than the height, the row will shrink to fit the content. Will not have any effect if `height` is set and is smaller than `max_height`.
+            min_height: The minimum height of the row, specified in pixels if a number is passed, or in CSS units if a string is passed. If content exceeds the height, the row will expand to fit the content. Will not have any effect if `height` is set and is larger than `min_height`.
+            equal_height: If True, makes every child element have equal height
+            show_progress: If True, shows progress animation when being updated.
+        """
+        self.variant = variant
+        self.equal_height = equal_height
+        if variant == "compact":
+            self.allow_expected_parents = False
+        self.show_progress = show_progress
+        self.height = height
+        self.max_height = max_height
+        self.min_height = min_height
+
+        BlockContext.__init__(
+            self,
+            visible=visible,
+            elem_id=elem_id,
+            elem_classes=elem_classes,
+            render=render,
+        )
+
+    @staticmethod
+    def update(
+        visible: bool | None = None,
+    ):
+        return {
+            "visible": visible,
+            "__type__": "update",
+        }

evalkit_tf437/lib/python3.10/site-packages/gradio/layouts/row.pyi

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from gradio_client.documentation import document
+
+from gradio.blocks import BlockContext
+from gradio.component_meta import ComponentMeta
+
+from gradio.events import Dependency
+
+@document()
+class Row(BlockContext, metaclass=ComponentMeta):
+    """
+    Row is a layout element within Blocks that renders all children horizontally.
+    Example:
+        with gr.Blocks() as demo:
+            with gr.Row():
+                gr.Image("lion.jpg", scale=2)
+                gr.Image("tiger.jpg", scale=1)
+        demo.launch()
+    Guides: controlling-layout
+    """
+
+    EVENTS = []
+
+    def __init__(
+        self,
+        *,
+        variant: Literal["default", "panel", "compact"] = "default",
+        visible: bool = True,
+        elem_id: str | None = None,
+        elem_classes: list[str] | str | None = None,
+        render: bool = True,
+        height: int | str | None = None,
+        max_height: int | str | None = None,
+        min_height: int | str | None = None,
+        equal_height: bool = False,
+        show_progress: bool = False,
+    ):
+        """
+        Parameters:
+            variant: row type, 'default' (no background), 'panel' (gray background color and rounded corners), or 'compact' (rounded corners and no internal gap).
+            visible: If False, row will be hidden.
+            elem_id: An optional string that is assigned as the id of this component in the HTML DOM. Can be used for targeting CSS styles.
+            elem_classes: An optional string or list of strings that are assigned as the class of this component in the HTML DOM. Can be used for targeting CSS styles.
+            render: If False, this layout will not be rendered in the Blocks context. Should be used if the intention is to assign event listeners now but render the component later.
+            height: The height of the row, specified in pixels if a number is passed, or in CSS units if a string is passed. If content exceeds the height, the row will scroll vertically. If not set, the row will expand to fit the content.
+            max_height: The maximum height of the row, specified in pixels if a number is passed, or in CSS units if a string is passed. If content exceeds the height, the row will scroll vertically. If content is shorter than the height, the row will shrink to fit the content. Will not have any effect if `height` is set and is smaller than `max_height`.
+            min_height: The minimum height of the row, specified in pixels if a number is passed, or in CSS units if a string is passed. If content exceeds the height, the row will expand to fit the content. Will not have any effect if `height` is set and is larger than `min_height`.
+            equal_height: If True, makes every child element have equal height
+            show_progress: If True, shows progress animation when being updated.
+        """
+        self.variant = variant
+        self.equal_height = equal_height
+        if variant == "compact":
+            self.allow_expected_parents = False
+        self.show_progress = show_progress
+        self.height = height
+        self.max_height = max_height
+        self.min_height = min_height
+
+        BlockContext.__init__(
+            self,
+            visible=visible,
+            elem_id=elem_id,
+            elem_classes=elem_classes,
+            render=render,
+        )
+
+    @staticmethod
+    def update(
+        visible: bool | None = None,
+    ):
+        return {
+            "visible": visible,
+            "__type__": "update",
+        }
+    from typing import Callable, Literal, Sequence, Any, TYPE_CHECKING
+    from gradio.blocks import Block
+    if TYPE_CHECKING:
+        from gradio.components import Timer

evalkit_tf437/lib/python3.10/site-packages/gradio/layouts/tabs.pyi

@@ -0,0 +1,246 @@
+from __future__ import annotations
+
+from gradio_client.documentation import document
+
+from gradio.blocks import BlockContext
+from gradio.component_meta import ComponentMeta
+from gradio.events import Events
+
+from gradio.events import Dependency
+
+class Tabs(BlockContext, metaclass=ComponentMeta):
+    """
+    Tabs is a layout element within Blocks that can contain multiple "Tab" Components.
+    """
+
+    EVENTS = [Events.change, Events.select]
+
+    def __init__(
+        self,
+        *,
+        selected: int | str | None = None,
+        visible: bool = True,
+        elem_id: str | None = None,
+        elem_classes: list[str] | str | None = None,
+        render: bool = True,
+    ):
+        """
+        Parameters:
+            selected: The currently selected tab. Must correspond to an id passed to the one of the child TabItems. Defaults to the first TabItem.
+            visible: If False, Tabs will be hidden.
+            elem_id: An optional string that is assigned as the id of this component in the HTML DOM. Can be used for targeting CSS styles.
+            elem_classes: An optional string or list of strings that are assigned as the class of this component in the HTML DOM. Can be used for targeting CSS styles.
+            render: If False, this layout will not be rendered in the Blocks context. Should be used if the intention is to assign event listeners now but render the component later.
+        """
+        BlockContext.__init__(
+            self,
+            visible=visible,
+            elem_id=elem_id,
+            elem_classes=elem_classes,
+            render=render,
+        )
+        self.selected = selected
+    from typing import Callable, Literal, Sequence, Any, TYPE_CHECKING
+    from gradio.blocks import Block
+    if TYPE_CHECKING:
+        from gradio.components import Timer
+
+    
+    def change(self,
+        fn: Callable[..., Any] | None = None,
+        inputs: Block | Sequence[Block] | set[Block] | None = None,
+        outputs: Block | Sequence[Block] | None = None,
+        api_name: str | None | Literal[False] = None,
+        scroll_to_output: bool = False,
+        show_progress: Literal["full", "minimal", "hidden"] = "full",
+        queue: bool | None = None,
+        batch: bool = False,
+        max_batch_size: int = 4,
+        preprocess: bool = True,
+        postprocess: bool = True,
+        cancels: dict[str, Any] | list[dict[str, Any]] | None = None,
+        every: Timer | float | None = None,
+        trigger_mode: Literal["once", "multiple", "always_last"] | None = None,
+        js: str | None = None,
+        concurrency_limit: int | None | Literal["default"] = "default",
+        concurrency_id: str | None = None,
+        show_api: bool = True,
+    
+        ) -> Dependency:
+        """
+        Parameters:
+            fn: the function to call when this event is triggered. Often a machine learning model's prediction function. Each parameter of the function corresponds to one input component, and the function should return a single value or a tuple of values, with each element in the tuple corresponding to one output component.
+            inputs: list of gradio.components to use as inputs. If the function takes no inputs, this should be an empty list.
+            outputs: list of gradio.components to use as outputs. If the function returns no outputs, this should be an empty list.
+            api_name: defines how the endpoint appears in the API docs. Can be a string, None, or False. If False, the endpoint will not be exposed in the api docs. If set to None, the endpoint will be exposed in the api docs as an unnamed endpoint, although this behavior will be changed in Gradio 4.0. If set to a string, the endpoint will be exposed in the api docs with the given name.
+            scroll_to_output: if True, will scroll to output component on completion
+            show_progress: how to show the progress animation while event is running: "full" shows a spinner which covers the output component area as well as a runtime display in the upper right corner, "minimal" only shows the runtime display, "hidden" shows no progress animation at all
+            queue: if True, will place the request on the queue, if the queue has been enabled. If False, will not put this event on the queue, even if the queue has been enabled. If None, will use the queue setting of the gradio app.
+            batch: if True, then the function should process a batch of inputs, meaning that it should accept a list of input values for each parameter. The lists should be of equal length (and be up to length `max_batch_size`). The function is then *required* to return a tuple of lists (even if there is only 1 output component), with each list in the tuple corresponding to one output component.
+            max_batch_size: maximum number of inputs to batch together if this is called from the queue (only relevant if batch=True)
+            preprocess: if False, will not run preprocessing of component data before running 'fn' (e.g. leaving it as a base64 string if this method is called with the `Image` component).
+            postprocess: if False, will not run postprocessing of component data before returning 'fn' output to the browser.
+            cancels: a list of other events to cancel when this listener is triggered. For example, setting cancels=[click_event] will cancel the click_event, where click_event is the return value of another components .click method. Functions that have not yet run (or generators that are iterating) will be cancelled, but functions that are currently running will be allowed to finish.
+            every: continously calls `value` to recalculate it if `value` is a function (has no effect otherwise). Can provide a Timer whose tick resets `value`, or a float that provides the regular interval for the reset Timer.
+            trigger_mode: if "once" (default for all events except `.change()`) would not allow any submissions while an event is pending. If set to "multiple", unlimited submissions are allowed while pending, and "always_last" (default for `.change()` and `.key_up()` events) would allow a second submission after the pending event is complete.
+            js: optional frontend js method to run before running 'fn'. Input arguments for js method are values of 'inputs' and 'outputs', return should be a list of values for output components.
+            concurrency_limit: if set, this is the maximum number of this event that can be running simultaneously. Can be set to None to mean no concurrency_limit (any number of this event can be running simultaneously). Set to "default" to use the default concurrency limit (defined by the `default_concurrency_limit` parameter in `Blocks.queue()`, which itself is 1 by default).
+            concurrency_id: if set, this is the id of the concurrency group. Events with the same concurrency_id will be limited by the lowest set concurrency_limit.
+            show_api: whether to show this event in the "view API" page of the Gradio app, or in the ".view_api()" method of the Gradio clients. Unlike setting api_name to False, setting show_api to False will still allow downstream apps as well as the Clients to use this event. If fn is None, show_api will automatically be set to False.
+        
+        """
+        ...
+    
+    def select(self,
+        fn: Callable[..., Any] | None = None,
+        inputs: Block | Sequence[Block] | set[Block] | None = None,
+        outputs: Block | Sequence[Block] | None = None,
+        api_name: str | None | Literal[False] = None,
+        scroll_to_output: bool = False,
+        show_progress: Literal["full", "minimal", "hidden"] = "full",
+        queue: bool | None = None,
+        batch: bool = False,
+        max_batch_size: int = 4,
+        preprocess: bool = True,
+        postprocess: bool = True,
+        cancels: dict[str, Any] | list[dict[str, Any]] | None = None,
+        every: Timer | float | None = None,
+        trigger_mode: Literal["once", "multiple", "always_last"] | None = None,
+        js: str | None = None,
+        concurrency_limit: int | None | Literal["default"] = "default",
+        concurrency_id: str | None = None,
+        show_api: bool = True,
+    
+        ) -> Dependency:
+        """
+        Parameters:
+            fn: the function to call when this event is triggered. Often a machine learning model's prediction function. Each parameter of the function corresponds to one input component, and the function should return a single value or a tuple of values, with each element in the tuple corresponding to one output component.
+            inputs: list of gradio.components to use as inputs. If the function takes no inputs, this should be an empty list.
+            outputs: list of gradio.components to use as outputs. If the function returns no outputs, this should be an empty list.
+            api_name: defines how the endpoint appears in the API docs. Can be a string, None, or False. If False, the endpoint will not be exposed in the api docs. If set to None, the endpoint will be exposed in the api docs as an unnamed endpoint, although this behavior will be changed in Gradio 4.0. If set to a string, the endpoint will be exposed in the api docs with the given name.
+            scroll_to_output: if True, will scroll to output component on completion
+            show_progress: how to show the progress animation while event is running: "full" shows a spinner which covers the output component area as well as a runtime display in the upper right corner, "minimal" only shows the runtime display, "hidden" shows no progress animation at all
+            queue: if True, will place the request on the queue, if the queue has been enabled. If False, will not put this event on the queue, even if the queue has been enabled. If None, will use the queue setting of the gradio app.
+            batch: if True, then the function should process a batch of inputs, meaning that it should accept a list of input values for each parameter. The lists should be of equal length (and be up to length `max_batch_size`). The function is then *required* to return a tuple of lists (even if there is only 1 output component), with each list in the tuple corresponding to one output component.
+            max_batch_size: maximum number of inputs to batch together if this is called from the queue (only relevant if batch=True)
+            preprocess: if False, will not run preprocessing of component data before running 'fn' (e.g. leaving it as a base64 string if this method is called with the `Image` component).
+            postprocess: if False, will not run postprocessing of component data before returning 'fn' output to the browser.
+            cancels: a list of other events to cancel when this listener is triggered. For example, setting cancels=[click_event] will cancel the click_event, where click_event is the return value of another components .click method. Functions that have not yet run (or generators that are iterating) will be cancelled, but functions that are currently running will be allowed to finish.
+            every: continously calls `value` to recalculate it if `value` is a function (has no effect otherwise). Can provide a Timer whose tick resets `value`, or a float that provides the regular interval for the reset Timer.
+            trigger_mode: if "once" (default for all events except `.change()`) would not allow any submissions while an event is pending. If set to "multiple", unlimited submissions are allowed while pending, and "always_last" (default for `.change()` and `.key_up()` events) would allow a second submission after the pending event is complete.
+            js: optional frontend js method to run before running 'fn'. Input arguments for js method are values of 'inputs' and 'outputs', return should be a list of values for output components.
+            concurrency_limit: if set, this is the maximum number of this event that can be running simultaneously. Can be set to None to mean no concurrency_limit (any number of this event can be running simultaneously). Set to "default" to use the default concurrency limit (defined by the `default_concurrency_limit` parameter in `Blocks.queue()`, which itself is 1 by default).
+            concurrency_id: if set, this is the id of the concurrency group. Events with the same concurrency_id will be limited by the lowest set concurrency_limit.
+            show_api: whether to show this event in the "view API" page of the Gradio app, or in the ".view_api()" method of the Gradio clients. Unlike setting api_name to False, setting show_api to False will still allow downstream apps as well as the Clients to use this event. If fn is None, show_api will automatically be set to False.
+        
+        """
+        ...
+
+
+@document()
+class Tab(BlockContext, metaclass=ComponentMeta):
+    """
+    Tab (or its alias TabItem) is a layout element. Components defined within the Tab will be visible when this tab is selected tab.
+    Example:
+        with gr.Blocks() as demo:
+            with gr.Tab("Lion"):
+                gr.Image("lion.jpg")
+                gr.Button("New Lion")
+            with gr.Tab("Tiger"):
+                gr.Image("tiger.jpg")
+                gr.Button("New Tiger")
+    Guides: controlling-layout
+    """
+
+    EVENTS = [Events.select]
+
+    def __init__(
+        self,
+        label: str | None = None,
+        visible: bool = True,
+        interactive: bool = True,
+        *,
+        id: int | str | None = None,
+        elem_id: str | None = None,
+        elem_classes: list[str] | str | None = None,
+        render: bool = True,
+    ):
+        """
+        Parameters:
+            label: The visual label for the tab
+            id: An optional identifier for the tab, required if you wish to control the selected tab from a predict function.
+            elem_id: An optional string that is assigned as the id of the <div> containing the contents of the Tab layout. The same string followed by "-button" is attached to the Tab button. Can be used for targeting CSS styles.
+            elem_classes: An optional string or list of strings that are assigned as the class of this component in the HTML DOM. Can be used for targeting CSS styles.
+            render: If False, this layout will not be rendered in the Blocks context. Should be used if the intention is to assign event listeners now but render the component later.
+            visible: If False, Tab will be hidden.
+            interactive: If False, Tab will not be clickable.
+        """
+        BlockContext.__init__(
+            self,
+            elem_id=elem_id,
+            elem_classes=elem_classes,
+            render=render,
+        )
+        self.label = label
+        self.id = id
+        self.visible = visible
+        self.interactive = interactive
+
+    def get_expected_parent(self) -> type[Tabs]:
+        return Tabs
+
+    def get_block_name(self):
+        return "tabitem"
+    from typing import Callable, Literal, Sequence, Any, TYPE_CHECKING
+    from gradio.blocks import Block
+    if TYPE_CHECKING:
+        from gradio.components import Timer
+
+    
+    def select(self,
+        fn: Callable[..., Any] | None = None,
+        inputs: Block | Sequence[Block] | set[Block] | None = None,
+        outputs: Block | Sequence[Block] | None = None,
+        api_name: str | None | Literal[False] = None,
+        scroll_to_output: bool = False,
+        show_progress: Literal["full", "minimal", "hidden"] = "full",
+        queue: bool | None = None,
+        batch: bool = False,
+        max_batch_size: int = 4,
+        preprocess: bool = True,
+        postprocess: bool = True,
+        cancels: dict[str, Any] | list[dict[str, Any]] | None = None,
+        every: Timer | float | None = None,
+        trigger_mode: Literal["once", "multiple", "always_last"] | None = None,
+        js: str | None = None,
+        concurrency_limit: int | None | Literal["default"] = "default",
+        concurrency_id: str | None = None,
+        show_api: bool = True,
+    
+        ) -> Dependency:
+        """
+        Parameters:
+            fn: the function to call when this event is triggered. Often a machine learning model's prediction function. Each parameter of the function corresponds to one input component, and the function should return a single value or a tuple of values, with each element in the tuple corresponding to one output component.
+            inputs: list of gradio.components to use as inputs. If the function takes no inputs, this should be an empty list.
+            outputs: list of gradio.components to use as outputs. If the function returns no outputs, this should be an empty list.
+            api_name: defines how the endpoint appears in the API docs. Can be a string, None, or False. If False, the endpoint will not be exposed in the api docs. If set to None, the endpoint will be exposed in the api docs as an unnamed endpoint, although this behavior will be changed in Gradio 4.0. If set to a string, the endpoint will be exposed in the api docs with the given name.
+            scroll_to_output: if True, will scroll to output component on completion
+            show_progress: how to show the progress animation while event is running: "full" shows a spinner which covers the output component area as well as a runtime display in the upper right corner, "minimal" only shows the runtime display, "hidden" shows no progress animation at all
+            queue: if True, will place the request on the queue, if the queue has been enabled. If False, will not put this event on the queue, even if the queue has been enabled. If None, will use the queue setting of the gradio app.
+            batch: if True, then the function should process a batch of inputs, meaning that it should accept a list of input values for each parameter. The lists should be of equal length (and be up to length `max_batch_size`). The function is then *required* to return a tuple of lists (even if there is only 1 output component), with each list in the tuple corresponding to one output component.
+            max_batch_size: maximum number of inputs to batch together if this is called from the queue (only relevant if batch=True)
+            preprocess: if False, will not run preprocessing of component data before running 'fn' (e.g. leaving it as a base64 string if this method is called with the `Image` component).
+            postprocess: if False, will not run postprocessing of component data before returning 'fn' output to the browser.
+            cancels: a list of other events to cancel when this listener is triggered. For example, setting cancels=[click_event] will cancel the click_event, where click_event is the return value of another components .click method. Functions that have not yet run (or generators that are iterating) will be cancelled, but functions that are currently running will be allowed to finish.
+            every: continously calls `value` to recalculate it if `value` is a function (has no effect otherwise). Can provide a Timer whose tick resets `value`, or a float that provides the regular interval for the reset Timer.
+            trigger_mode: if "once" (default for all events except `.change()`) would not allow any submissions while an event is pending. If set to "multiple", unlimited submissions are allowed while pending, and "always_last" (default for `.change()` and `.key_up()` events) would allow a second submission after the pending event is complete.
+            js: optional frontend js method to run before running 'fn'. Input arguments for js method are values of 'inputs' and 'outputs', return should be a list of values for output components.
+            concurrency_limit: if set, this is the maximum number of this event that can be running simultaneously. Can be set to None to mean no concurrency_limit (any number of this event can be running simultaneously). Set to "default" to use the default concurrency limit (defined by the `default_concurrency_limit` parameter in `Blocks.queue()`, which itself is 1 by default).
+            concurrency_id: if set, this is the id of the concurrency group. Events with the same concurrency_id will be limited by the lowest set concurrency_limit.
+            show_api: whether to show this event in the "view API" page of the Gradio app, or in the ".view_api()" method of the Gradio clients. Unlike setting api_name to False, setting show_api to False will still allow downstream apps as well as the Clients to use this event. If fn is None, show_api will automatically be set to False.
+        
+        """
+        ...
+
+
+TabItem = Tab

evalkit_tf437/lib/python3.10/site-packages/gradio/templates/node/build/client/_app/immutable/chunks/Example.Ce2XkglX.js.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fbe21d4781d9fc216e2e81ee375b6a53f63c8ba89c9d3d8d43acaa9d6289a954
+size 818

evalkit_tf437/lib/python3.10/site-packages/gradio/templates/node/build/client/_app/immutable/chunks/Gallery.HXgWnEV3.js.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:79928e08b0ab7d2e4bbf6b8a078147124c99f1f0273f4ec017c1deb098028358
+size 10165

evalkit_tf437/lib/python3.10/site-packages/gradio/templates/node/build/client/_app/immutable/chunks/IconButtonWrapper.y99hkeYc.js.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5401684dc6676e53e9c33939523ffcb284824ffdec894f8b464e25159ffeff38
+size 1009