Add files using upload-large-folder tool

testbed/gradio-app__gradio/.changeset/README.md

@@ -0,0 +1,8 @@
+# Changesets
+
+Hello and welcome! This folder has been automatically generated by `@changesets/cli`, a build tool that works
+with multi-package repos, or single-package repos to help you version and publish your code. You can
+find the full documentation for it [in our repository](https://github.com/changesets/changesets)
+
+We have a quick list of common questions to get you started engaging with this project in
+[our documentation](https://github.com/changesets/changesets/blob/main/docs/common-questions.md)

testbed/gradio-app__gradio/.changeset/changeset.cjs

@@ -0,0 +1,280 @@
+const { getPackagesSync } = require("@manypkg/get-packages");
+const gh = require("@changesets/get-github-info");
+const { existsSync, readFileSync, writeFileSync } = require("fs");
+const { join } = require("path");
+
+const { getInfo, getInfoFromPullRequest } = gh;
+const { packages, rootDir } = getPackagesSync(process.cwd());
+
+/**
+ * @typedef {{packageJson: {name: string, python?: boolean}, dir: string}} Package
+ */
+
+/**
+ * @typedef {{summary: string, id: string, commit: string, releases: {name: string}}} Changeset
+ */
+
+/**
+ *
+ * @param {string} package_name The name of the package to find the directories for
+ * @returns {string[]} The directories for the package
+ */
+function find_packages_dirs(package_name) {
+	/** @type {string[]} */
+	let package_dirs = [];
+
+	/** @type {Package | undefined} */
+	const _package = packages.find((p) => p.packageJson.name === package_name);
+	if (!_package) throw new Error(`Package ${package_name} not found`);
+
+	package_dirs.push(_package.dir);
+	if (_package.packageJson.python) {
+		package_dirs.push(join(_package.dir, ".."));
+	}
+	return package_dirs;
+}
+
+const changelogFunctions = {
+	/**
+	 *
+	 * @param {Changeset[]} changesets The changesets that have been created
+	 * @param {any} dependenciesUpdated The dependencies that have been updated
+	 * @param {any} options The options passed to the changelog generator
+	 * @returns {Promise<string>} The release line for the dependencies
+	 */
+	getDependencyReleaseLine: async (
+		changesets,
+		dependenciesUpdated,
+		options
+	) => {
+		if (!options.repo) {
+			throw new Error(
+				'Please provide a repo to this changelog generator like this:\n"changelog": ["@changesets/changelog-github", { "repo": "org/repo" }]'
+			);
+		}
+		if (dependenciesUpdated.length === 0) return "";
+
+		const changesetLink = `- Updated dependencies [${(
+			await Promise.all(
+				changesets.map(async (cs) => {
+					if (cs.commit) {
+						let { links } = await getInfo({
+							repo: options.repo,
+							commit: cs.commit
+						});
+						return links.commit;
+					}
+				})
+			)
+		)
+			.filter((_) => _)
+			.join(", ")}]:`;
+
+		const updatedDepenenciesList = dependenciesUpdated.map(
+			/**
+			 *
+			 * @param {any} dependency The dependency that has been updated
+			 * @returns {string} The formatted dependency
+			 */
+			(dependency) => `  - ${dependency.name}@${dependency.newVersion}`
+		);
+
+		return [changesetLink, ...updatedDepenenciesList].join("\n");
+	},
+	/**
+	 *
+	 * @param {{summary: string, id: string, commit: string, releases: {name: string}[]}} changeset The changeset that has been created
+	 * @param {any} type The type of changeset
+	 * @param {any} options The options passed to the changelog generator
+	 * @returns {Promise<string>} The release line for the changeset
+	 */
+	getReleaseLine: async (changeset, type, options) => {
+		if (!options || !options.repo) {
+			throw new Error(
+				'Please provide a repo to this changelog generator like this:\n"changelog": ["@changesets/changelog-github", { "repo": "org/repo" }]'
+			);
+		}
+
+		let prFromSummary;
+		let commitFromSummary;
+		/**
+		 * @type {string[]}
+		 */
+		let usersFromSummary = [];
+
+		const replacedChangelog = changeset.summary
+			.replace(/^\s*(?:pr|pull|pull\s+request):\s*#?(\d+)/im, (_, pr) => {
+				let num = Number(pr);
+				if (!isNaN(num)) prFromSummary = num;
+				return "";
+			})
+			.replace(/^\s*commit:\s*([^\s]+)/im, (_, commit) => {
+				commitFromSummary = commit;
+				return "";
+			})
+			.replace(/^\s*(?:author|user):\s*@?([^\s]+)/gim, (_, user) => {
+				usersFromSummary.push(user);
+				return "";
+			})
+			.trim();
+
+		const [firstLine, ...futureLines] = replacedChangelog
+			.split("\n")
+			.map((l) => l.trimRight());
+
+		const links = await (async () => {
+			if (prFromSummary !== undefined) {
+				let { links } = await getInfoFromPullRequest({
+					repo: options.repo,
+					pull: prFromSummary
+				});
+				if (commitFromSummary) {
+					links = {
+						...links,
+						commit: `[\`${commitFromSummary}\`](https://github.com/${options.repo}/commit/${commitFromSummary})`
+					};
+				}
+				return links;
+			}
+			const commitToFetchFrom = commitFromSummary || changeset.commit;
+			if (commitToFetchFrom) {
+				let { links } = await getInfo({
+					repo: options.repo,
+					commit: commitToFetchFrom
+				});
+				return links;
+			}
+			return {
+				commit: null,
+				pull: null,
+				user: null
+			};
+		})();
+
+		const users =
+			usersFromSummary && usersFromSummary.length
+				? usersFromSummary
+						.map(
+							(userFromSummary) =>
+								`[@${userFromSummary}](https://github.com/${userFromSummary})`
+						)
+						.join(", ")
+				: links.user;
+
+		const prefix = [
+			links.pull === null ? "" : `${links.pull}`,
+			links.commit === null ? "" : `${links.commit}`
+		]
+			.join(" ")
+			.trim();
+
+		const suffix = users === null ? "" : ` Thanks ${users}!`;
+
+		/**
+		 * @typedef {{[key: string]: string[] | {dirs: string[], current_changelog: string, feat: {summary: string}[], fix: {summary: string}[], highlight: {summary: string}[]}}} ChangesetMeta
+		 */
+
+		/**
+		 * @type { ChangesetMeta & { _handled: string[] } }}
+		 */
+		let lines;
+		if (existsSync(join(rootDir, ".changeset", "_changelog.json"))) {
+			lines = JSON.parse(
+				readFileSync(join(rootDir, ".changeset", "_changelog.json"), "utf-8")
+			);
+		} else {
+			lines = {
+				_handled: []
+			};
+		}
+
+		if (lines._handled.includes(changeset.id)) {
+			return "done";
+		}
+		lines._handled.push(changeset.id);
+
+		changeset.releases.forEach((release) => {
+			if (!lines[release.name])
+				lines[release.name] = {
+					dirs: find_packages_dirs(release.name),
+					current_changelog: "",
+					feat: [],
+					fix: [],
+					highlight: []
+				};
+
+			const changelog_path = join(
+				//@ts-ignore
+				lines[release.name].dirs[1] || lines[release.name].dirs[0],
+				"CHANGELOG.md"
+			);
+
+			if (existsSync(changelog_path)) {
+				//@ts-ignore
+				lines[release.name].current_changelog = readFileSync(
+					changelog_path,
+					"utf-8"
+				)
+					.replace(`# ${release.name}`, "")
+					.trim();
+			}
+
+			const [, _type, summary] = changeset.summary
+				.trim()
+				.match(/^(feat|fix|highlight)\s*:\s*([^]*)/im) || [
+				,
+				false,
+				changeset.summary
+			];
+
+			let formatted_summary = "";
+
+			if (_type === "highlight") {
+				const [heading, ...rest] = summary.trim().split("\n");
+				const _heading = `${heading} ${prefix ? `(${prefix})` : ""}`;
+				const _rest = rest.concat(["", suffix]);
+
+				formatted_summary = `${_heading}\n${_rest.join("\n")}`;
+			} else {
+				formatted_summary = handle_line(summary, prefix, suffix);
+			}
+
+			//@ts-ignore
+			lines[release.name][_type].push({
+				summary: formatted_summary
+			});
+		});
+
+		writeFileSync(
+			join(rootDir, ".changeset", "_changelog.json"),
+			JSON.stringify(lines, null, 2)
+		);
+
+		return `\n\n-${prefix ? `${prefix} -` : ""} ${firstLine}\n${futureLines
+			.map((l) => `  ${l}`)
+			.join("\n")}`;
+	}
+};
+
+/**
+ * @param {string} str The changelog entry
+ * @param {string} prefix The prefix to add to the first line
+ * @param {string} suffix The suffix to add to the last line
+ * @returns {string} The formatted changelog entry
+ */
+function handle_line(str, prefix, suffix) {
+	const [_s, ...lines] = str.split("\n").filter(Boolean);
+
+	const desc = `${prefix ? `${prefix} -` : ""} ${_s.replace(
+		/[\s\.]$/,
+		""
+	)}. ${suffix}`;
+
+	if (_s.length === 1) {
+		return desc;
+	}
+
+	return [desc, ...lines.map((l) => `  ${l}`)].join("/n");
+}
+
+module.exports = changelogFunctions;

testbed/gradio-app__gradio/.changeset/config.json

@@ -0,0 +1,11 @@
+{
+	"$schema": "https://unpkg.com/@changesets/config@2.3.0/schema.json",
+	"changelog": ["./changeset.cjs", { "repo": "gradio-app/gradio" }],
+	"commit": false,
+	"fixed": [],
+	"linked": [],
+	"access": "public",
+	"baseBranch": "main",
+	"updateInternalDependencies": "patch",
+	"ignore": ["@gradio/spaces-test", "@gradio/cdn-test"]
+}

testbed/gradio-app__gradio/.changeset/fix_changelogs.cjs

@@ -0,0 +1,122 @@
+const { join } = require("path");
+const { readFileSync, existsSync, writeFileSync, unlinkSync } = require("fs");
+const { getPackagesSync } = require("@manypkg/get-packages");
+
+const RE_PKG_NAME = /^[\w-]+\b/;
+const pkg_meta = getPackagesSync(process.cwd());
+
+/**
+ * @typedef {{dirs: string[], highlight: {summary: string}[], feat: {summary: string}[], fix: {summary: string}[], current_changelog: string}} ChangesetMeta
+ */
+
+/**
+ * @typedef {{[key: string]: ChangesetMeta}} ChangesetMetaCollection
+ */
+
+function run() {
+	if (!existsSync(join(pkg_meta.rootDir, ".changeset", "_changelog.json"))) {
+		console.warn("No changesets to process");
+		return;
+	}
+
+	/**
+	 * @type { ChangesetMetaCollection & { _handled: string[] } }}
+	 */
+	const { _handled, ...packages } = JSON.parse(
+		readFileSync(
+			join(pkg_meta.rootDir, ".changeset", "_changelog.json"),
+			"utf-8"
+		)
+	);
+
+	/**
+	 * @typedef { {packageJson: {name: string, version: string, python: boolean}, dir: string} } PackageMeta
+	 */
+
+	/**
+	 * @type { {[key:string]: PackageMeta} }
+	 */
+	const all_packages = pkg_meta.packages.reduce((acc, pkg) => {
+		acc[pkg.packageJson.name] = /**@type {PackageMeta} */ (
+			/** @type {unknown} */ (pkg)
+		);
+		return acc;
+	}, /** @type {{[key:string] : PackageMeta}} */ ({}));
+
+	for (const pkg_name in packages) {
+		const { dirs, highlight, feat, fix, current_changelog } =
+			/**@type {ChangesetMeta} */ (packages[pkg_name]);
+
+		const { version, python } = all_packages[pkg_name].packageJson;
+
+		const highlights = highlight.map((h) => `${h.summary}`);
+		const features = feat.map((f) => `- ${f.summary}`);
+		const fixes = fix.map((f) => `- ${f.summary}`);
+
+		const release_notes = /** @type {[string[], string][]} */ ([
+			[highlights, "### Highlights"],
+			[features, "### Features"],
+			[fixes, "### Fixes"]
+		])
+			.filter(([s], i) => s.length > 0)
+			.map(([lines, title]) => {
+				if (title === "### Highlights") {
+					return `${title}\n\n${lines.join("\n\n")}`;
+				}
+
+				return `${title}\n\n${lines.join("\n")}`;
+			})
+			.join("\n\n");
+
+		const new_changelog = `# ${pkg_name}
+
+## ${version}
+
+${release_notes}
+
+${current_changelog.replace(`# ${pkg_name}`, "").trim()}
+`.trim();
+
+		dirs.forEach((dir) => {
+			writeFileSync(join(dir, "CHANGELOG.md"), new_changelog);
+		});
+
+		if (python) {
+			bump_local_dependents(pkg_name, version);
+		}
+	}
+
+	unlinkSync(join(pkg_meta.rootDir, ".changeset", "_changelog.json"));
+
+	/**
+	 * @param {string} pkg_to_bump The name of the package to bump
+	 * @param {string} version The version to bump to
+	 * @returns {void}
+	 * */
+	function bump_local_dependents(pkg_to_bump, version) {
+		for (const pkg_name in all_packages) {
+			const {
+				dir,
+				packageJson: { python }
+			} = all_packages[pkg_name];
+
+			if (!python) continue;
+
+			const requirements_path = join(dir, "..", "requirements.txt");
+			const requirements = readFileSync(requirements_path, "utf-8").split("\n");
+
+			const pkg_index = requirements.findIndex((line) => {
+				const m = line.trim().match(RE_PKG_NAME);
+				if (!m) return false;
+				return m[0] === pkg_to_bump;
+			});
+
+			if (pkg_index !== -1) {
+				requirements[pkg_index] = `${pkg_to_bump}==${version}`;
+				writeFileSync(requirements_path, requirements.join("\n"));
+			}
+		}
+	}
+}
+
+run();

testbed/gradio-app__gradio/.config/.prettierignore

@@ -0,0 +1,27 @@
+**/js/app/public/**
+**/pnpm-workspace.yaml
+**/js/app/dist/**
+**/js/wasm/dist/**
+**/client/js/dist/**
+**/js/lite/dist/**
+**/pnpm-lock.yaml
+**/js/plot/src/Plot.svelte
+**/.svelte-kit/**
+**/demo/**
+**/gradio/**
+**/.pnpm-store/**
+**/.venv/**
+**/.github/**
+/guides/**
+**/.mypy_cache/**
+!test-strategy.md
+**/js/_space-test/**
+../js/app/src/lite/theme.css
+../js/storybook/theme.css
+**/gradio_cached_examples/**
+**/storybook-static/**  
+**/.vscode/**
+sweep.yaml
+**/.vercel/**
+**/build/**
+**/*.md

testbed/gradio-app__gradio/.config/.prettierrc.json

@@ -0,0 +1,7 @@
+{
+	"useTabs": true,
+	"singleQuote": false,
+	"trailingComma": "none",
+	"printWidth": 80,
+	"plugins": ["prettier-plugin-svelte"]
+}

testbed/gradio-app__gradio/.config/basevite.config.ts

@@ -0,0 +1,91 @@
+import { defineConfig } from "vite";
+import { svelte } from "@sveltejs/vite-plugin-svelte";
+import sveltePreprocess from "svelte-preprocess";
+// @ts-ignore
+import custom_media from "postcss-custom-media";
+import global_data from "@csstools/postcss-global-data";
+// @ts-ignore
+import prefixer from "postcss-prefix-selector";
+import { readFileSync } from "fs";
+import { join } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = fileURLToPath(new URL(".", import.meta.url));
+const version_path = join(__dirname, "..", "gradio", "package.json");
+const theme_token_path = join(
+	__dirname,
+	"..",
+	"js",
+	"theme",
+	"src",
+	"tokens.css"
+);
+
+const version = JSON.parse(readFileSync(version_path, { encoding: 'utf-8' })).version.trim().replace(/\./g, '-');
+
+//@ts-ignore
+export default defineConfig(({ mode }) => {
+	const production =
+		mode === "production:cdn" ||
+		mode === "production:local" ||
+		mode === "production:website";
+
+	return {
+		server: {
+			port: 9876
+		},
+
+		build: {
+			sourcemap: false,
+			target: "esnext",
+			minify: production
+		},
+		define: {
+			BUILD_MODE: production ? JSON.stringify("prod") : JSON.stringify("dev"),
+			BACKEND_URL: production
+				? JSON.stringify("")
+				: JSON.stringify("http://localhost:7860/"),
+			GRADIO_VERSION: JSON.stringify(version)
+		},
+		css: {
+			postcss: {
+				plugins: [
+					prefixer({
+						prefix: `.gradio-container-${version}`,
+						// @ts-ignore
+						transform(prefix, selector, prefixedSelector, fileName) {
+							if (selector.indexOf("gradio-container") > -1) {
+								return prefix;
+							} else if (
+								selector.indexOf(":root") > -1 ||
+								selector.indexOf("dark") > -1 ||
+								fileName.indexOf(".svelte") > -1
+							) {
+								return selector;
+							}
+							return prefixedSelector;
+						}
+					}),
+					custom_media()
+				]
+			}
+		},
+		plugins: [
+			svelte({
+				inspector: true,
+				compilerOptions: {
+					dev: !production
+				},
+				hot: !process.env.VITEST && !production,
+				preprocess: sveltePreprocess({
+					postcss: {
+						plugins: [
+							global_data({ files: [theme_token_path] }),
+							custom_media()
+						]
+					}
+				})
+			})
+		]
+	};
+});

testbed/gradio-app__gradio/.config/eslint.config.js

@@ -0,0 +1,142 @@
+import globals from "globals";
+import ts_plugin from "@typescript-eslint/eslint-plugin";
+import js_plugin from "@eslint/js";
+
+import typescriptParser from "@typescript-eslint/parser";
+import sveltePlugin from "eslint-plugin-svelte";
+import svelteParser from "svelte-eslint-parser";
+
+const ts_rules_disabled = Object.fromEntries(
+	Object.keys(ts_plugin.rules).map((rule) => [
+		`@typescript-eslint/${rule}`,
+		"off"
+	])
+);
+const js_rules_disabled = Object.fromEntries(
+	Object.keys(js_plugin.configs.all.rules).map((rule) => [rule, "off"])
+);
+
+const js_rules = {
+	...js_rules_disabled,
+	"no-console": ["error", { allow: ["warn", "error", "debug"] }],
+	"no-constant-condition": "error",
+	"no-dupe-args": "error",
+	"no-extra-boolean-cast": "error",
+	"no-unexpected-multiline": "error",
+	"no-unreachable": "error",
+	"valid-jsdoc": "error",
+	"array-callback-return": "error",
+	complexity: "error",
+	"no-else-return": "error",
+	"no-useless-return": "error",
+	"no-undef": "error"
+};
+
+const ts_rules = {
+	...ts_rules_disabled,
+	"@typescript-eslint/adjacent-overload-signatures": "error",
+	"@typescript-eslint/explicit-function-return-type": [
+		"error",
+		{ allowExpressions: true }
+	],
+	"@typescript-eslint/consistent-type-exports": "error",
+	"@typescript-eslint/ban-types": "error",
+	"@typescript-eslint/array-type": "error",
+	"@typescript-eslint/no-inferrable-types": "error"
+};
+
+const { browser, es2021, node } = globals;
+
+export default [
+	{
+		ignores: [
+			".svelte-kit/**/*",
+			"**/node_modules/**",
+			"**/dist/**",
+			"**/.config/*",
+			"**/*.spec.ts",
+			"**/*.test.ts",
+			"**/*.node-test.ts",
+			"js/app/test/**/*",
+			"**/*vite.config.ts",
+			"**/_website/**/*",
+			"**/_spaces-test/**/*"
+		]
+	},
+	{
+		files: ["**/*.js", "**/*.cjs"],
+		languageOptions: {
+			globals: {
+				...browser,
+				...es2021,
+				...node
+			}
+		},
+
+		plugins: {
+			"eslint:recommended": js_plugin
+		},
+		rules: js_rules
+	},
+
+	{
+		files: ["**/*.ts"],
+		languageOptions: {
+			parser: typescriptParser,
+			parserOptions: {
+				project: "./tsconfig.json",
+				extraFileExtensions: [".svelte"]
+			},
+			globals: {
+				...browser,
+				...es2021,
+				...node
+			}
+		},
+
+		plugins: {
+			"@typescript-eslint": ts_plugin,
+			"eslint:recommended": js_plugin
+		},
+		rules: {
+			...ts_rules,
+			...js_rules,
+			"no-undef": "off"
+		}
+	},
+	{
+		files: ["**/client/js/**"],
+		languageOptions: {
+			parserOptions: {
+				project: "./client/js/tsconfig.json"
+			}
+		}
+	},
+	{
+		files: ["**/*.svelte"],
+		languageOptions: {
+			parser: svelteParser,
+			parserOptions: {
+				parser: typescriptParser,
+				project: "./tsconfig.json",
+				extraFileExtensions: [".svelte"]
+			},
+			globals: {
+				...browser,
+				...es2021
+			}
+		},
+		plugins: {
+			svelte: sveltePlugin,
+			"@typescript-eslint": ts_plugin,
+			"eslint:recommended": js_plugin
+		},
+		rules: {
+			...ts_rules,
+			...js_rules,
+			...sveltePlugin.configs.recommended.rules,
+			"svelte/no-at-html-tags": "off",
+			"no-undef": "off"
+		}
+	}
+];

testbed/gradio-app__gradio/.config/playwright-ct.config.ts

@@ -0,0 +1,41 @@
+import { defineConfig, devices } from "@playwright/experimental-ct-svelte";
+import config from "./basevite.config";
+
+/**
+ * See https://playwright.dev/docs/test-configuration.
+ */
+export default defineConfig({
+	testDir: "../",
+	/* The base directory, relative to the config file, for snapshot files created with toMatchSnapshot and toHaveScreenshot. */
+	snapshotDir: "./__snapshots__",
+	/* Maximum time one test can run for. */
+	timeout: 10 * 1000,
+	/* Run tests in files in parallel */
+	fullyParallel: true,
+	/* Fail the build on CI if you accidentally left test.only in the source code. */
+	forbidOnly: !!process.env.CI,
+	/* Retry on CI only */
+	retries: process.env.CI ? 2 : 0,
+	/* Opt out of parallel tests on CI. */
+	workers: process.env.CI ? 1 : undefined,
+	/* Reporter to use. See https://playwright.dev/docs/test-reporters */
+	reporter: "html",
+	/* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */
+	use: {
+		/* Collect trace when retrying the failed test. See https://playwright.dev/docs/trace-viewer */
+		trace: "on-first-retry",
+
+		/* Port to use for Playwright component endpoint. */
+		ctPort: 3100,
+		ctViteConfig: config({ mode: "development" })
+	},
+	testMatch: "*.component.spec.ts",
+
+	/* Configure projects for major browsers */
+	projects: [
+		{
+			name: "chromium",
+			use: { ...devices["Desktop Chrome"] }
+		}
+	]
+});

testbed/gradio-app__gradio/.config/playwright-setup.js

@@ -0,0 +1,151 @@
+import { spawn } from "node:child_process";
+import { join, basename } from "path";
+import { fileURLToPath } from "url";
+import { readdirSync, writeFileSync } from "fs";
+import net from "net";
+
+import kl from "kleur";
+
+const __dirname = fileURLToPath(new URL(".", import.meta.url));
+const TEST_APP_PATH = join(__dirname, "./test.py");
+const TEST_FILES_PATH = join(__dirname, "..", "js", "app", "test");
+const ROOT = join(__dirname, "..");
+
+const test_files = readdirSync(TEST_FILES_PATH)
+	.filter(
+		(f) =>
+			f.endsWith("spec.ts") &&
+			!f.endsWith(".skip.spec.ts") &&
+			!f.endsWith(".component.spec.ts")
+	)
+	.map((f) => basename(f, ".spec.ts"));
+
+export default async function global_setup() {
+	const verbose = process.env.GRADIO_TEST_VERBOSE;
+
+	const port = await find_free_port(7860, 8860);
+	process.env.GRADIO_E2E_TEST_PORT = port;
+
+	process.stdout.write(kl.yellow("\nCreating test gradio app.\n\n"));
+
+	const test_app = make_app(test_files, port);
+	process.stdout.write(kl.yellow("App created. Starting test server.\n\n"));
+
+	process.stdout.write(kl.bgBlue(" =========================== \n"));
+	process.stdout.write(kl.bgBlue(" === PYTHON STARTUP LOGS === \n"));
+	process.stdout.write(kl.bgBlue(" =========================== \n\n"));
+
+	writeFileSync(TEST_APP_PATH, test_app);
+
+	const app = await spawn_gradio_app(TEST_APP_PATH, port, verbose);
+
+	process.stdout.write(
+		kl.green(`\n\nServer started. Running tests on port ${port}.\n`)
+	);
+
+	return () => {
+		process.stdout.write(kl.green(`\nTests complete, cleaning up!\n`));
+
+		kill_process(app);
+	};
+}
+const INFO_RE = /^INFO:/;
+
+function spawn_gradio_app(app, port, verbose) {
+	const PORT_RE = new RegExp(`:${port}`);
+
+	return new Promise((res, rej) => {
+		const _process = spawn(`python`, [app], {
+			shell: true,
+			stdio: "pipe",
+			cwd: ROOT,
+			env: {
+				...process.env,
+				GRADIO_SERVER_PORT: `7879`,
+				PYTHONUNBUFFERED: "true"
+			}
+		});
+		_process.stdout.setEncoding("utf8");
+
+		function std_out(data) {
+			const _data = data.toString();
+			const is_info = INFO_RE.test(_data);
+
+			if (is_info) {
+				process.stdout.write(kl.yellow(_data));
+			}
+
+			if (!is_info) {
+				process.stdout.write(`${_data}\n`);
+			}
+
+			if (PORT_RE.test(_data)) {
+				process.stdout.write(kl.bgBlue("\n =========== END =========== "));
+
+				res(_process);
+
+				if (!verbose) {
+					_process.stdout.off("data", std_out);
+					_process.stderr.off("data", std_out);
+				}
+			}
+		}
+
+		_process.stdout.on("data", std_out);
+		_process.stderr.on("data", std_out);
+		_process.on("exit", () => kill_process(_process));
+		_process.on("close", () => kill_process(_process));
+		_process.on("disconnect", () => kill_process(_process));
+	});
+}
+
+function kill_process(process) {
+	process.kill("SIGKILL");
+}
+
+function make_app(demos, port) {
+	return `import gradio as gr
+import uvicorn
+from fastapi import FastAPI
+import gradio as gr
+${demos.map((d) => `from demo.${d}.run import demo as ${d}`).join("\n")}
+
+app = FastAPI()
+${demos
+	.map((d) => `app = gr.mount_gradio_app(app, ${d}, path="/${d}")`)
+	.join("\n")}
+
+config = uvicorn.Config(app, port=${port}, log_level="info")
+server = uvicorn.Server(config=config)
+server.run()`;
+}
+
+export async function find_free_port(start_port, end_port) {
+	for (let port = start_port; port < end_port; port++) {
+		if (await is_free_port(port)) {
+			return port;
+		}
+	}
+
+	throw new Error(
+		`Could not find free ports: there were not enough ports available.`
+	);
+}
+
+export function is_free_port(port) {
+	return new Promise((accept, reject) => {
+		const sock = net.createConnection(port, "127.0.0.1");
+		sock.once("connect", () => {
+			sock.end();
+			accept(false);
+		});
+		sock.once("error", (e) => {
+			sock.destroy();
+			if (e.code === "ECONNREFUSED") {
+				accept(true);
+			} else {
+				reject(e);
+			}
+		});
+	});
+}

testbed/gradio-app__gradio/.config/playwright.config.js

@@ -0,0 +1,9 @@
+export default {
+	use: {
+		screenshot: "only-on-failure",
+		trace: "retain-on-failure"
+	},
+	testMatch: /.*.spec.ts/,
+	testDir: "..",
+	globalSetup: "./playwright-setup.js"
+};

testbed/gradio-app__gradio/.config/playwright/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+	<head>
+		<meta charset="UTF-8" />
+		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+		<title>Testing Page</title>
+	</head>
+	<body>
+		<div id="root"></div>
+		<script type="module" src="./index.ts"></script>
+	</body>
+</html>

testbed/gradio-app__gradio/.config/playwright/index.ts

@@ -0,0 +1,2 @@
+// Import styles, initialize component theme here.
+// import '../src/common.css';

testbed/gradio-app__gradio/.config/postcss.config.cjs

@@ -0,0 +1,8 @@
+const tailwindcss = require("tailwindcss");
+const autoprefixer = require("autoprefixer");
+const nested = require("tailwindcss/nesting");
+const tw_config = require("./tailwind.config.cjs");
+
+module.exports = {
+	plugins: [nested, tailwindcss(tw_config), autoprefixer]
+};

testbed/gradio-app__gradio/.config/setup_vite_tests.ts

@@ -0,0 +1,11 @@
+import type { TestingLibraryMatchers } from "@testing-library/jest-dom/matchers";
+import matchers from "@testing-library/jest-dom/matchers";
+import { expect } from "vitest";
+
+declare module "vitest" {
+	interface Assertion<T = any>
+		extends jest.Matchers<void, T>,
+			TestingLibraryMatchers<T, void> {}
+}
+
+expect.extend(matchers);

testbed/gradio-app__gradio/.config/tailwind.config.cjs

@@ -0,0 +1,12 @@
+module.exports = {
+	content: [
+		"./src/**/*.{html,js,svelte,ts}",
+		"**/@gradio/**/*.{html,js,svelte,ts}"
+	],
+
+	theme: {
+		extend: {}
+	},
+
+	plugins: [require("@tailwindcss/forms")]
+};

testbed/gradio-app__gradio/.config/vitest.config.ts

@@ -0,0 +1,3 @@
+import config from "../js/app/vite.config";
+
+export default config;

testbed/gradio-app__gradio/.devcontainer/devcontainer.json

@@ -0,0 +1,41 @@
+// See https://containers.dev
+{
+	"name": "Python 3",
+	"image": "mcr.microsoft.com/devcontainers/python:0-3.9",
+
+	// See https://containers.dev/features
+	"features": {
+		"ghcr.io/devcontainers/features/git:1": {},
+		"ghcr.io/devcontainers/features/node:1": {},
+		"ghcr.io/devcontainers-contrib/features/ffmpeg-apt-get:1": {}
+	},
+
+	"hostRequirements": {
+		"cpus": 4,
+		"memory": "8gb",
+		"storage": "32gb"
+	},
+
+	"customizations": {
+		"vscode": {
+			"extensions": [
+				"ms-python.python",
+				"ms-python.vscode-pylance",
+				"ms-python.black-formatter",
+				"ms-toolsai.jupyter",
+				"esbenp.prettier-vscode",
+				"svelte.svelte-vscode",
+				"phoenisx.cssvar"
+			],
+			"remote.autoForwardPorts": false
+		}
+	},
+
+	"forwardPorts": [7860, 9876],
+	"portsAttributes": {
+		"7860": { "label": "gradio port" },
+		"9876": { "label": "gradio dev port" }
+	},
+
+	"postCreateCommand": "export NODE_OPTIONS=\"--max-old-space-size=8192\" && chmod +x scripts/install_gradio.sh scripts/install_test_requirements.sh scripts/build_frontend.sh && ./scripts/install_gradio.sh && ./scripts/install_test_requirements.sh && ./scripts/build_frontend.sh"
+}

testbed/gradio-app__gradio/README.md

@@ -0,0 +1,323 @@
+<!-- DO NOT EDIT THIS FILE DIRECTLY. INSTEAD EDIT THE `readme_template.md` OR `guides/1)getting_started/1)quickstart.md` TEMPLATES AND THEN RUN `render_readme.py` SCRIPT. -->
+
+<div align="center">
+
+[<img src="readme_files/gradio.svg" alt="gradio" width=300>](https://gradio.app)<br>
+<em>Build & share delightful machine learning apps easily</em>
+
+[![gradio-backend](https://github.com/gradio-app/gradio/actions/workflows/backend.yml/badge.svg)](https://github.com/gradio-app/gradio/actions/workflows/backend.yml)
+[![gradio-ui](https://github.com/gradio-app/gradio/actions/workflows/ui.yml/badge.svg)](https://github.com/gradio-app/gradio/actions/workflows/ui.yml)  
+ [![PyPI](https://img.shields.io/pypi/v/gradio)](https://pypi.org/project/gradio/)
+[![PyPI downloads](https://img.shields.io/pypi/dm/gradio)](https://pypi.org/project/gradio/)
+![Python version](https://img.shields.io/badge/python-3.8+-important)
+[![Twitter follow](https://img.shields.io/twitter/follow/gradio?style=social&label=follow)](https://twitter.com/gradio)
+
+[Website](https://gradio.app)
+| [Documentation](https://gradio.app/docs/)
+| [Guides](https://gradio.app/guides/)
+| [Getting Started](https://gradio.app/getting_started/)
+| [Examples](demo/)
+| [中文](readme_files/zh-cn#readme)
+
+</div>
+
+# Gradio: Build Machine Learning Web Apps — in Python
+
+Gradio is an open-source Python library that is used to build machine learning and data science demos and web applications.
+
+With Gradio, you can quickly create a beautiful user interface around your machine learning models or data science workflow and let people "try it out" by dragging-and-dropping in their own images,
+pasting text, recording their own voice, and interacting with your demo, all through the browser.
+
+![Interface montage](readme_files/header-image.jpg)
+
+Gradio is useful for:
+
+- **Demoing** your machine learning models for clients/collaborators/users/students.
+
+- **Deploying** your models quickly with automatic shareable links and getting feedback on model performance.
+
+- **Debugging** your model interactively during development using built-in manipulation and interpretation tools.
+
+## Quickstart
+
+**Prerequisite**: Gradio requires Python 3.8 or higher, that's all!
+
+### What Does Gradio Do?
+
+One of the _best ways to share_ your machine learning model, API, or data science workflow with others is to create an **interactive app** that allows your users or colleagues to try out the demo in their browsers.
+
+Gradio allows you to **build demos and share them, all in Python.** And usually in just a few lines of code! So let's get started.
+
+### Hello, World
+
+To get Gradio running with a simple "Hello, World" example, follow these three steps:
+
+1\. Install Gradio using pip:
+
+```bash
+pip install gradio
+```
+
+2\. Run the code below as a Python script or in a Jupyter Notebook (or [Google Colab](https://colab.research.google.com/drive/18ODkJvyxHutTN0P5APWyGFO_xwNcgHDZ?usp=sharing)):
+
+```python
+import gradio as gr
+
+def greet(name):
+    return "Hello " + name + "!"
+
+demo = gr.Interface(fn=greet, inputs="text", outputs="text")
+    
+demo.launch()
+```
+
+
+We shorten the imported name to `gr` for better readability of code using Gradio. This is a widely adopted convention that you should follow so that anyone working with your code can easily understand it.
+
+3\. The demo below will appear automatically within the Jupyter Notebook, or pop in a browser on [http://localhost:7860](http://localhost:7860) if running from a script:
+
+![`hello_world` demo](demo/hello_world/screenshot.gif)
+
+When developing locally, if you want to run the code as a Python script, you can use the Gradio CLI to launch the application **in reload mode**, which will provide seamless and fast development. Learn more about reloading in the [Auto-Reloading Guide](https://gradio.app/developing-faster-with-reload-mode/).
+
+```bash
+gradio app.py
+```
+
+Note: you can also do `python app.py`, but it won't provide the automatic reload mechanism.
+
+### The `Interface` Class
+
+You'll notice that in order to make the demo, we created a `gr.Interface`. This `Interface` class can wrap any Python function with a user interface. In the example above, we saw a simple text-based function, but the function could be anything from music generator to a tax calculator to the prediction function of a pretrained machine learning model.
+
+The core `Interface` class is initialized with three required parameters:
+
+- `fn`: the function to wrap a UI around
+- `inputs`: which component(s) to use for the input (e.g. `"text"`, `"image"` or `"audio"`)
+- `outputs`: which component(s) to use for the output (e.g. `"text"`, `"image"` or `"label"`)
+
+Let's take a closer look at these components used to provide input and output.
+
+### Components Attributes
+
+We saw some simple `Textbox` components in the previous examples, but what if you want to change how the UI components look or behave?
+
+Let's say you want to customize the input text field — for example, you wanted it to be larger and have a text placeholder. If we use the actual class for `Textbox` instead of using the string shortcut, you have access to much more customizability through component attributes.
+
+```python
+import gradio as gr
+
+def greet(name):
+    return "Hello " + name + "!"
+
+demo = gr.Interface(
+    fn=greet,
+    inputs=gr.Textbox(lines=2, placeholder="Name Here..."),
+    outputs="text",
+)
+demo.launch()
+```
+
+![`hello_world_2` demo](demo/hello_world_2/screenshot.gif)
+
+### Multiple Input and Output Components
+
+Suppose you had a more complex function, with multiple inputs and outputs. In the example below, we define a function that takes a string, boolean, and number, and returns a string and number. Take a look how you pass a list of input and output components.
+
+```python
+import gradio as gr
+
+def greet(name, is_morning, temperature):
+    salutation = "Good morning" if is_morning else "Good evening"
+    greeting = f"{salutation} {name}. It is {temperature} degrees today"
+    celsius = (temperature - 32) * 5 / 9
+    return greeting, round(celsius, 2)
+
+demo = gr.Interface(
+    fn=greet,
+    inputs=["text", "checkbox", gr.Slider(0, 100)],
+    outputs=["text", "number"],
+)
+demo.launch()
+```
+
+![`hello_world_3` demo](demo/hello_world_3/screenshot.gif)
+
+You simply wrap the components in a list. Each component in the `inputs` list corresponds to one of the parameters of the function, in order. Each component in the `outputs` list corresponds to one of the values returned by the function, again in order.
+
+### An Image Example
+
+Gradio supports many types of components, such as `Image`, `DataFrame`, `Video`, or `Label`. Let's try an image-to-image function to get a feel for these!
+
+```python
+import numpy as np
+import gradio as gr
+
+def sepia(input_img):
+    sepia_filter = np.array([
+        [0.393, 0.769, 0.189], 
+        [0.349, 0.686, 0.168], 
+        [0.272, 0.534, 0.131]
+    ])
+    sepia_img = input_img.dot(sepia_filter.T)
+    sepia_img /= sepia_img.max()
+    return sepia_img
+
+demo = gr.Interface(sepia, gr.Image(shape=(200, 200)), "image")
+demo.launch()
+```
+
+![`sepia_filter` demo](demo/sepia_filter/screenshot.gif)
+
+When using the `Image` component as input, your function will receive a NumPy array with the shape `(height, width, 3)`, where the last dimension represents the RGB values. We'll return an image as well in the form of a NumPy array.
+
+You can also set the datatype used by the component with the `type=` keyword argument. For example, if you wanted your function to take a file path to an image instead of a NumPy array, the input `Image` component could be written as:
+
+```python
+gr.Image(type="filepath", shape=...)
+```
+
+Also note that our input `Image` component comes with an edit button 🖉, which allows for cropping and zooming into images. Manipulating images in this way can help reveal biases or hidden flaws in a machine learning model!
+
+You can read more about the many components and how to use them in the [Gradio docs](https://gradio.app/docs).
+
+### Chatbots
+
+Gradio includes a high-level class, `gr.ChatInterface`, which is similar to `gr.Interface`, but is specifically designed for chatbot UIs. The `gr.ChatInterface` class also wraps a function but this function must have a specific signature. The function should take two arguments: `message` and then `history` (the arguments can be named anything, but must be in this order)
+
+- `message`: a `str` representing the user's input
+- `history`: a `list` of `list` representing the conversations up until that point. Each inner list consists of two `str` representing a pair: `[user input, bot response]`.
+
+Your function should return a single string response, which is the bot's response to the particular user input `message`.
+
+Other than that, `gr.ChatInterface` has no required parameters (though several are available for customization of the UI).
+
+Here's a toy example:
+
+```python
+import random
+import gradio as gr
+
+def random_response(message, history):
+    return random.choice(["Yes", "No"])
+
+demo = gr.ChatInterface(random_response)
+
+demo.launch()
+```
+
+![`chatinterface_random_response` demo](demo/chatinterface_random_response/screenshot.gif)
+
+You can [read more about `gr.ChatInterface` here](https://gradio.app/guides/creating-a-chatbot-fast).
+
+### Blocks: More Flexibility and Control
+
+Gradio offers two approaches to build apps:
+
+1\. **Interface** and **ChatInterface**, which provide a high-level abstraction for creating demos that we've been discussing so far.
+
+2\. **Blocks**, a low-level API for designing web apps with more flexible layouts and data flows. Blocks allows you to do things like feature multiple data flows and demos, control where components appear on the page, handle complex data flows (e.g. outputs can serve as inputs to other functions), and update properties/visibility of components based on user interaction — still all in Python. If this customizability is what you need, try `Blocks` instead!
+
+### Hello, Blocks
+
+Let's take a look at a simple example. Note how the API here differs from `Interface`.
+
+```python
+import gradio as gr
+
+def greet(name):
+    return "Hello " + name + "!"
+
+with gr.Blocks() as demo:
+    name = gr.Textbox(label="Name")
+    output = gr.Textbox(label="Output Box")
+    greet_btn = gr.Button("Greet")
+    greet_btn.click(fn=greet, inputs=name, outputs=output, api_name="greet")
+
+demo.launch()
+```
+
+![`hello_blocks` demo](demo/hello_blocks/screenshot.gif)
+
+Things to note:
+
+- `Blocks` are made with a `with` clause, and any component created inside this clause is automatically added to the app.
+- Components appear vertically in the app in the order they are created. (Later we will cover customizing layouts!)
+- A `Button` was created, and then a `click` event-listener was added to this button. The API for this should look familiar! Like an `Interface`, the `click` method takes a Python function, input components, and output components.
+
+### More Complexity
+
+Here's an app to give you a taste of what's possible with `Blocks`:
+
+```python
+import numpy as np
+import gradio as gr
+
+
+def flip_text(x):
+    return x[::-1]
+
+
+def flip_image(x):
+    return np.fliplr(x)
+
+
+with gr.Blocks() as demo:
+    gr.Markdown("Flip text or image files using this demo.")
+    with gr.Tab("Flip Text"):
+        text_input = gr.Textbox()
+        text_output = gr.Textbox()
+        text_button = gr.Button("Flip")
+    with gr.Tab("Flip Image"):
+        with gr.Row():
+            image_input = gr.Image()
+            image_output = gr.Image()
+        image_button = gr.Button("Flip")
+
+    with gr.Accordion("Open for More!"):
+        gr.Markdown("Look at me...")
+
+    text_button.click(flip_text, inputs=text_input, outputs=text_output)
+    image_button.click(flip_image, inputs=image_input, outputs=image_output)
+
+demo.launch()
+```
+
+![`blocks_flipper` demo](demo/blocks_flipper/screenshot.gif)
+
+A lot more going on here! We'll cover how to create complex `Blocks` apps like this in the [building with blocks](https://gradio.app/blocks-and-event-listeners) section for you.
+
+Congrats, you're now familiar with the basics of Gradio! 🥳 Go to our [next guide](https://gradio.app/key_features) to learn more about the key features of Gradio.
+
+
+## Open Source Stack
+
+Gradio is built with many wonderful open-source libraries, please support them as well!
+
+[<img src="readme_files/huggingface_mini.svg" alt="huggingface" height=40>](https://huggingface.co)
+[<img src="readme_files/python.svg" alt="python" height=40>](https://www.python.org)
+[<img src="readme_files/fastapi.svg" alt="fastapi" height=40>](https://fastapi.tiangolo.com)
+[<img src="readme_files/encode.svg" alt="encode" height=40>](https://www.encode.io)
+[<img src="readme_files/svelte.svg" alt="svelte" height=40>](https://svelte.dev)
+[<img src="readme_files/vite.svg" alt="vite" height=40>](https://vitejs.dev)
+[<img src="readme_files/pnpm.svg" alt="pnpm" height=40>](https://pnpm.io)
+[<img src="readme_files/tailwind.svg" alt="tailwind" height=40>](https://tailwindcss.com)
+[<img src="readme_files/storybook.svg" alt="storybook" height=40>](https://storybook.js.org/)
+[<img src="readme_files/chromatic.svg" alt="chromatic" height=40>](https://www.chromatic.com/)
+
+## License
+
+Gradio is licensed under the Apache License 2.0 found in the [LICENSE](LICENSE) file in the root directory of this repository.
+
+## Citation
+
+Also check out the paper _[Gradio: Hassle-Free Sharing and Testing of ML Models in the Wild](https://arxiv.org/abs/1906.02569), ICML HILL 2019_, and please cite it if you use Gradio in your work.
+
+```
+@article{abid2019gradio,
+  title = {Gradio: Hassle-Free Sharing and Testing of ML Models in the Wild},
+  author = {Abid, Abubakar and Abdalla, Ali and Abid, Ali and Khan, Dawood and Alfozan, Abdulrahman and Zou, James},
+  journal = {arXiv preprint arXiv:1906.02569},
+  year = {2019},
+}
+```

testbed/gradio-app__gradio/client/js/CHANGELOG.md

@@ -0,0 +1,80 @@
+# @gradio/client
+
+## 0.4.0
+
+### Features
+
+- [#5682](https://github.com/gradio-app/gradio/pull/5682) [`c57f1b75e`](https://github.com/gradio-app/gradio/commit/c57f1b75e272c76b0af4d6bd0c7f44743ff34f26) - Fix functional tests.  Thanks [@abidlabs](https://github.com/abidlabs)!
+- [#5681](https://github.com/gradio-app/gradio/pull/5681) [`40de3d217`](https://github.com/gradio-app/gradio/commit/40de3d2178b61ebe424b6f6228f94c0c6f679bea) - add query parameters to the `gr.Request` object through the `query_params` attribute.  Thanks [@DarhkVoyd](https://github.com/DarhkVoyd)!
+- [#5653](https://github.com/gradio-app/gradio/pull/5653) [`ea0e00b20`](https://github.com/gradio-app/gradio/commit/ea0e00b207b4b90a10e9d054c4202d4e705a29ba) - Prevent Clients from accessing API endpoints that set `api_name=False`.  Thanks [@abidlabs](https://github.com/abidlabs)!
+
+## 0.3.1
+
+### Fixes
+
+- [#5412](https://github.com/gradio-app/gradio/pull/5412) [`26fef8c7`](https://github.com/gradio-app/gradio/commit/26fef8c7f85a006c7e25cdbed1792df19c512d02) - Skip view_api request in js client when auth enabled.  Thanks [@freddyaboulton](https://github.com/freddyaboulton)!
+
+## 0.3.0
+
+### Features
+
+- [#5267](https://github.com/gradio-app/gradio/pull/5267) [`119c8343`](https://github.com/gradio-app/gradio/commit/119c834331bfae60d4742c8f20e9cdecdd67e8c2) - Faster reload mode.  Thanks [@freddyaboulton](https://github.com/freddyaboulton)!
+
+## 0.2.1
+
+### Features
+
+- [#5173](https://github.com/gradio-app/gradio/pull/5173) [`730f0c1d`](https://github.com/gradio-app/gradio/commit/730f0c1d54792eb11359e40c9f2326e8a6e39203) - Ensure gradio client works as expected for functions that return nothing.  Thanks [@raymondtri](https://github.com/raymondtri)!
+
+## 0.2.0
+
+### Features
+
+- [#5133](https://github.com/gradio-app/gradio/pull/5133) [`61129052`](https://github.com/gradio-app/gradio/commit/61129052ed1391a75c825c891d57fa0ad6c09fc8) - Update dependency esbuild to ^0.19.0. Thanks [@renovate](https://github.com/apps/renovate)!
+- [#5035](https://github.com/gradio-app/gradio/pull/5035) [`8b4eb8ca`](https://github.com/gradio-app/gradio/commit/8b4eb8cac9ea07bde31b44e2006ca2b7b5f4de36) - JS Client: Fixes cannot read properties of null (reading 'is_file'). Thanks [@raymondtri](https://github.com/raymondtri)!
+
+### Fixes
+
+- [#5075](https://github.com/gradio-app/gradio/pull/5075) [`67265a58`](https://github.com/gradio-app/gradio/commit/67265a58027ef1f9e4c0eb849a532f72eaebde48) - Allow supporting >1000 files in `gr.File()` and `gr.UploadButton()`. Thanks [@abidlabs](https://github.com/abidlabs)!
+
+## 0.1.4
+
+### Patch Changes
+
+- [#4717](https://github.com/gradio-app/gradio/pull/4717) [`ab5d1ea0`](https://github.com/gradio-app/gradio/commit/ab5d1ea0de87ed888779b66fd2a705583bd29e02) Thanks [@whitphx](https://github.com/whitphx)! - Fix the package description
+
+## 0.1.3
+
+### Patch Changes
+
+- [#4357](https://github.com/gradio-app/gradio/pull/4357) [`0dbd8f7f`](https://github.com/gradio-app/gradio/commit/0dbd8f7fee4b4877f783fa7bc493f98bbfc3d01d) Thanks [@pngwn](https://github.com/pngwn)! - Various internal refactors and cleanups.
+
+## 0.1.2
+
+### Patch Changes
+
+- [#4273](https://github.com/gradio-app/gradio/pull/4273) [`1d0f0a9d`](https://github.com/gradio-app/gradio/commit/1d0f0a9db096552e67eb2197c932342587e9e61e) Thanks [@pngwn](https://github.com/pngwn)! - Ensure websocket error messages are correctly handled.
+
+- [#4315](https://github.com/gradio-app/gradio/pull/4315) [`b525b122`](https://github.com/gradio-app/gradio/commit/b525b122dd8569bbaf7e06db5b90d622d2e9073d) Thanks [@whitphx](https://github.com/whitphx)! - Refacor types.
+
+- [#4271](https://github.com/gradio-app/gradio/pull/4271) [`1151c525`](https://github.com/gradio-app/gradio/commit/1151c5253554cb87ebd4a44a8a470ac215ff782b) Thanks [@pngwn](https://github.com/pngwn)! - Ensure the full root path is always respected when making requests to a gradio app server.
+
+## 0.1.1
+
+### Patch Changes
+
+- [#4201](https://github.com/gradio-app/gradio/pull/4201) [`da5b4ee1`](https://github.com/gradio-app/gradio/commit/da5b4ee11721175858ded96e5710225369097f74) Thanks [@pngwn](https://github.com/pngwn)! - Ensure semiver is bundled so CDN links work correctly.
+
+- [#4202](https://github.com/gradio-app/gradio/pull/4202) [`a26e9afd`](https://github.com/gradio-app/gradio/commit/a26e9afde319382993e6ddc77cc4e56337a31248) Thanks [@pngwn](https://github.com/pngwn)! - Ensure all URLs returned by the client are complete URLs with the correct host instead of an absolute path relative to a server.
+
+## 0.1.0
+
+### Minor Changes
+
+- [#4185](https://github.com/gradio-app/gradio/pull/4185) [`67239ca9`](https://github.com/gradio-app/gradio/commit/67239ca9b2fe3796853fbf7bf865c9e4b383200d) Thanks [@pngwn](https://github.com/pngwn)! - Update client for initial release
+
+### Patch Changes
+
+- [#3692](https://github.com/gradio-app/gradio/pull/3692) [`48e8b113`](https://github.com/gradio-app/gradio/commit/48e8b113f4b55e461d9da4f153bf72aeb4adf0f1) Thanks [@pngwn](https://github.com/pngwn)! - Ensure client works in node, create ESM bundle and generate typescript declaration files.
+
+- [#3605](https://github.com/gradio-app/gradio/pull/3605) [`ae4277a9`](https://github.com/gradio-app/gradio/commit/ae4277a9a83d49bdadfe523b0739ba988128e73b) Thanks [@pngwn](https://github.com/pngwn)! - Update readme.

testbed/gradio-app__gradio/client/js/README.md

@@ -0,0 +1,339 @@
+## JavaScript Client Library
+
+A javascript (and typescript) client to call Gradio APIs.
+
+## Installation
+
+The Gradio JavaScript client is available on npm as `@gradio/client`. You can install it as below:
+
+```sh
+npm i @gradio/client
+```
+
+## Usage
+
+The JavaScript Gradio Client exposes two named imports, `client` and `duplicate`.
+
+### `client`
+
+The client function connects to the API of a hosted Gradio space and returns an object that allows you to make calls to that API.
+
+The simplest example looks like this:
+
+```ts
+import { client } from "@gradio/client";
+
+const app = await client("user/space-name");
+const result = await app.predict("/predict");
+```
+
+This function accepts two arguments: `source` and `options`:
+
+#### `source`
+
+This is the url or name of the gradio app whose API you wish to connect to. This parameter is required and should always be a string. For example:
+
+```ts
+client("user/space-name");
+```
+
+#### `options`
+
+The options object can optionally be passed a second parameter. This object has two properties, `hf_token` and `status_callback`.
+
+##### `hf_token`
+
+This should be a Hugging Face personal access token and is required if you wish to make calls to a private gradio api. This option is optional and should be a string starting with `"hf_"`.
+
+Example:
+
+```ts
+import { client } from "@gradio/client";
+
+const app = await client("user/space-name", { hf_token: "hf_..." });
+```
+
+##### `status_callback`
+
+This should be a function which will notify your of the status of a space if it is not running. If the gradio API you are connecting to is awake and running or is not hosted on Hugging Face space then this function will do nothing.
+
+**Additional context**
+
+Applications hosted on Hugging Face spaces can be in a number of different states. As spaces are a GitOps tool and will rebuild when new changes are pushed to the repository, they have various building, running and error states. If a space is not 'running' then the function passed as the `status_callback` will notify you of the current state of the space and the status of the space as it changes. Spaces that are building or sleeping can take longer than usual to respond, so you can use this information to give users feedback about the progress of their action.
+
+```ts
+import { client, type SpaceStatus } from "@gradio/client";
+
+const app = await client("user/space-name", {
+	// The space_status parameter does not need to be manually annotated, this is just for illustration.
+	space_status: (space_status: SpaceStatus) => console.log(space_status)
+});
+```
+
+```ts
+interface SpaceStatusNormal {
+	status: "sleeping" | "running" | "building" | "error" | "stopped";
+	detail:
+		| "SLEEPING"
+		| "RUNNING"
+		| "RUNNING_BUILDING"
+		| "BUILDING"
+		| "NOT_FOUND";
+	load_status: "pending" | "error" | "complete" | "generating";
+	message: string;
+}
+
+interface SpaceStatusError {
+	status: "space_error";
+	detail: "NO_APP_FILE" | "CONFIG_ERROR" | "BUILD_ERROR" | "RUNTIME_ERROR";
+	load_status: "error";
+	message: string;
+	discussions_enabled: boolean;
+
+type SpaceStatus = SpaceStatusNormal | SpaceStatusError;
+```
+
+The gradio client returns an object with a number of methods and properties:
+
+#### `predict`
+
+The `predict` method allows you to call an api endpoint and get a prediction result:
+
+```ts
+import { client } from "@gradio/client";
+
+const app = await client("user/space-name");
+const result = await app.predict("/predict");
+```
+
+`predict` accepts two parameters, `endpoint` and `payload`. It returns a promise that resolves to the prediction result.
+
+##### `endpoint`
+
+This is the endpoint for an api request and is required. The default endpoint for a `gradio.Interface` is `"/predict"`. Explicitly named endpoints have a custom name. The endpoint names can be found on the "View API" page of a space.
+
+```ts
+import { client } from "@gradio/client";
+
+const app = await client("user/space-name");
+const result = await app.predict("/predict");
+```
+
+##### `payload`
+
+The `payload` argument is generally optional but this depends on the API itself. If the API endpoint depends on values being passed in then it is required for the API request to succeed. The data that should be passed in is detailed on the "View API" page of a space, or accessible via the `view_api()` method of the client.
+
+```ts
+import { client } from "@gradio/client";
+
+const app = await client("user/space-name");
+const result = await app.predict("/predict", [1, "Hello", "friends"]);
+```
+
+#### `submit`
+
+The `submit` method provides a more flexible way to call an API endpoint, providing you with status updates about the current progress of the prediction as well as supporting more complex endpoint types.
+
+```ts
+import { client } from "@gradio/client";
+
+const app = await client("user/space-name");
+const submission = app.submit("/predict", payload);
+```
+
+The `submit` method accepts the same [`endpoint`](#endpoint) and [`payload`](#payload) arguments as `predict`.
+
+The `submit` method does not return a promise and should not be awaited, instead it returns an object with a `on`, `off`, and `cancel` methods.
+
+##### `on`
+
+The `on` method allows you to subscribe to events related to the submitted API request. There are two types of event that can be subscribed to: `"data"` updates and `"status"` updates.
+
+`"data"` updates are issued when the API computes a value, the callback provided as the second argument will be called when such a value is sent to the client. The shape of the data depends on the way the API itself is constructed. This event may fire more than once if that endpoint supports emmitting new values over time.
+
+`"status` updates are issued when the status of a request changes. This information allows you to offer feedback to users when the queue position of the request changes, or when the request changes from queued to processing.
+
+The status payload look like this:
+
+```ts
+interface Status {
+	queue: boolean;
+	code?: string;
+	success?: boolean;
+	stage: "pending" | "error" | "complete" | "generating";
+	size?: number;
+	position?: number;
+	eta?: number;
+	message?: string;
+	progress_data?: Array<{
+		progress: number | null;
+		index: number | null;
+		length: number | null;
+		unit: string | null;
+		desc: string | null;
+	}>;
+	time?: Date;
+}
+```
+
+Usage of these subscribe callback looks like this:
+
+```ts
+import { client } from "@gradio/client";
+
+const app = await client("user/space-name");
+const submission = app
+	.submit("/predict", payload)
+	.on("data", (data) => console.log(data))
+	.on("status", (status: Status) => console.log(status));
+```
+
+##### `off`
+
+The `off` method unsubscribes from a specific event of the submitted job and works similarly to `document.removeEventListener`; both the event name and the original callback must be passed in to successfully unsubscribe:
+
+```ts
+import { client } from "@gradio/client";
+
+const app = await client("user/space-name");
+const handle_data = (data) => console.log(data);
+
+const submission = app.submit("/predict", payload).on("data", handle_data);
+
+// later
+submission.off("/predict", handle_data);
+```
+
+##### `destroy`
+
+The `destroy` method will remove all subscriptions to a job, regardless of whether or not they are `"data"` or `"status"` events. This is a convenience method for when you do not want to unsubscribe use the `off` method.
+
+```js
+import { client } from "@gradio/client";
+
+const app = await client("user/space-name");
+const handle_data = (data) => console.log(data);
+
+const submission = app.submit("/predict", payload).on("data", handle_data);
+
+// later
+submission.destroy();
+```
+
+##### `cancel`
+
+Certain types of gradio function can run repeatedly and in some cases indefinitely. the `cancel` method will stop such an endpoints and prevent the API from issuing additional updates.
+
+```ts
+import { client } from "@gradio/client";
+
+const app = await client("user/space-name");
+const submission = app
+	.submit("/predict", payload)
+	.on("data", (data) => console.log(data));
+
+// later
+
+submission.cancel();
+```
+
+#### `view_api`
+
+The `view_api` method provides details about the API you are connected to. It returns a JavaScript object of all named endpoints, unnamed endpoints and what values they accept and return. This method does not accept arguments.
+
+```ts
+import { client } from "@gradio/client";
+
+const app = await client("user/space-name");
+const api_info = await app.view_api();
+
+console.log(api_info);
+```
+
+#### `config`
+
+The `config` property contains the configuration for the gradio application you are connected to. This object may contain useful meta information about the application.
+
+```ts
+import { client } from "@gradio/client";
+
+const app = await client("user/space-name");
+console.log(app.config);
+```
+
+### `duplicate`
+
+The duplicate function will attempt to duplicate the space that is referenced and return an instance of `client` connected to that space. If the space has already been duplicated then it will not create a new duplicate and will instead connect to the existing duplicated space. The huggingface token that is passed in will dictate the user under which the space is created.
+
+`duplicate` accepts the same arguments as `client` with the addition of a `private` options property dictating whether the duplicated space should be private or public. A huggingface token is required for duplication to work.
+
+```ts
+import { duplicate } from "@gradio/client";
+
+const app = await duplicate("user/space-name", {
+	hf_token: "hf_..."
+});
+```
+
+This function accepts two arguments: `source` and `options`:
+
+#### `source`
+
+The space to duplicate and connect to. [See `client`'s `source` parameter](#source).
+
+#### `options`
+
+Accepts all options that `client` accepts, except `hf_token` is required. [See `client`'s `options` parameter](#source).
+
+`duplicate` also accepts one additional `options` property.
+
+##### `private`
+
+This is an optional property specific to `duplicate`'s options object and will determine whether the space should be public or private. Spaces duplicated via the `duplicate` method are public by default.
+
+```ts
+import { duplicate } from "@gradio/client";
+
+const app = await duplicate("user/space-name", {
+	hf_token: "hf_...",
+	private: true
+});
+```
+
+##### `timeout`
+
+This is an optional property specific to `duplicate`'s options object and will set the timeout in minutes before the duplicated space will go to sleep.
+
+```ts
+import { duplicate } from "@gradio/client";
+
+const app = await duplicate("user/space-name", {
+	hf_token: "hf_...",
+	private: true,
+	timeout: 5
+});
+```
+
+##### `hardware`
+
+This is an optional property specific to `duplicate`'s options object and will set the hardware for the duplicated space. By default the hardware used will match that of the original space. If this cannot be obtained it will default to `"cpu-basic"`. For hardware upgrades (beyond the basic CPU tier), you may be required to provide [billing information on Hugging Face](https://huggingface.co/settings/billing).
+
+Possible hardware options are:
+
+- `"cpu-basic"`
+- `"cpu-upgrade"`
+- `"t4-small"`
+- `"t4-medium"`
+- `"a10g-small"`
+- `"a10g-large"`
+- `"a100-large"`
+
+```ts
+import { duplicate } from "@gradio/client";
+
+const app = await duplicate("user/space-name", {
+	hf_token: "hf_...",
+	private: true,
+	hardware: "a10g-small"
+});
+```

testbed/gradio-app__gradio/client/js/package.json

@@ -0,0 +1,33 @@
+{
+	"name": "@gradio/client",
+	"version": "0.4.0",
+	"description": "Gradio API client",
+	"type": "module",
+	"main": "dist/index.js",
+	"author": "",
+	"license": "ISC",
+	"exports": {
+		".": {
+			"import": "./dist/index.js"
+		},
+		"./package.json": "./package.json"
+	},
+	"dependencies": {
+		"bufferutil": "^4.0.7",
+		"semiver": "^1.1.0",
+		"ws": "^8.13.0"
+	},
+	"devDependencies": {
+		"@types/ws": "^8.5.4",
+		"esbuild": "^0.19.0"
+	},
+	"scripts": {
+		"bundle": "vite build --ssr",
+		"generate_types": "tsc",
+		"build": "pnpm bundle && pnpm generate_types"
+	},
+	"engines": {
+		"node": ">=18.0.0"
+	},
+	"main_changeset": true
+}

testbed/gradio-app__gradio/client/js/src/client.node-test.ts

@@ -0,0 +1,172 @@
+import { test, describe, assert } from "vitest";
+import { readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { Blob } from "node:buffer";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const image_path = join(
+	__dirname,
+	"..",
+	"..",
+	"..",
+	"demo",
+	"kitchen_sink",
+	"files",
+	"lion.jpg"
+);
+
+import { walk_and_store_blobs, client, handle_blob } from "./client";
+
+describe.skip("extract blob parts", () => {
+	test("convert Buffer to Blob", async () => {
+		const image = readFileSync(image_path);
+		await client("gradio/hello_world_main");
+		const parts = walk_and_store_blobs({
+			data: {
+				image
+			}
+		});
+
+		assert.isTrue(parts[0].blob instanceof Blob);
+	});
+
+	test("leave node Blob as Blob", async () => {
+		const image = new Blob([readFileSync(image_path)]);
+
+		await client("gradio/hello_world_main");
+		const parts = walk_and_store_blobs({
+			data: {
+				image
+			}
+		});
+
+		assert.isTrue(parts[0].blob instanceof Blob);
+	});
+
+	test("handle deep structures", async () => {
+		const image = new Blob([readFileSync(image_path)]);
+
+		await client("gradio/hello_world_main");
+		const parts = walk_and_store_blobs({
+			a: {
+				b: {
+					data: {
+						image
+					}
+				}
+			}
+		});
+
+		assert.isTrue(parts[0].blob instanceof Blob);
+	});
+
+	test("handle deep structures with arrays", async () => {
+		const image = new Blob([readFileSync(image_path)]);
+
+		await client("gradio/hello_world_main");
+		const parts = walk_and_store_blobs({
+			a: [
+				{
+					b: [
+						{
+							data: [
+								{
+									image
+								}
+							]
+						}
+					]
+				}
+			]
+		});
+
+		assert.isTrue(parts[0].blob instanceof Blob);
+	});
+
+	test("handle deep structures with arrays 2", async () => {
+		const image = new Blob([readFileSync(image_path)]);
+
+		await client("gradio/hello_world_main");
+		const obj = {
+			a: [
+				{
+					b: [
+						{
+							data: [[image], image, [image, [image]]]
+						}
+					]
+				}
+			]
+		};
+		const parts = walk_and_store_blobs(obj);
+
+		function map_path(
+			obj: Record<string, any>,
+			parts: { path: string[]; blob: any }[]
+		) {
+			const { path, blob } = parts[parts.length - 1];
+			let ref = obj;
+			path.forEach((p) => (ref = ref[p]));
+
+			return ref === blob;
+		}
+
+		assert.isTrue(parts[0].blob instanceof Blob);
+		// assert.isTrue(map_path(obj, parts));
+	});
+});
+
+describe("handle_blob", () => {
+	test("handle blobs", async () => {
+		const image = new Blob([readFileSync(image_path)]);
+
+		const app = await client("gradio/hello_world_main");
+		const obj = [
+			{
+				a: [
+					{
+						b: [
+							{
+								data: [[image], image, [image, [image]]]
+							}
+						]
+					}
+				]
+			}
+		];
+
+		const parts = await handle_blob(app.config.root, obj, undefined);
+		//@ts-ignore
+		// assert.isString(parts.data[0].a[0].b[0].data[0][0]);
+	});
+});
+
+describe.skip("private space", () => {
+	test("can access a private space", async () => {
+		const image = new Blob([readFileSync(image_path)]);
+
+		const app = await client("pngwn/hello_world", {
+			hf_token: "hf_"
+		});
+
+		console.log(app);
+		const obj = [
+			{
+				a: [
+					{
+						b: [
+							{
+								data: [[image], image, [image, [image]]]
+							}
+						]
+					}
+				]
+			}
+		];
+
+		const parts = await handle_blob(app.config.root, obj, "hf_");
+		//@ts-ignore
+		assert.isString(parts.data[0].a[0].b[0].data[0][0]);
+	});
+});

testbed/gradio-app__gradio/client/js/src/client.ts

@@ -0,0 +1,1367 @@
+import semiver from "semiver";
+
+import {
+	process_endpoint,
+	RE_SPACE_NAME,
+	map_names_to_ids,
+	discussions_enabled,
+	get_space_hardware,
+	set_space_hardware,
+	set_space_timeout,
+	hardware_types
+} from "./utils.js";
+
+import type {
+	EventType,
+	EventListener,
+	ListenerMap,
+	Event,
+	Payload,
+	PostResponse,
+	UploadResponse,
+	Status,
+	SpaceStatus,
+	SpaceStatusCallback,
+	FileData
+} from "./types.js";
+
+import type { Config } from "./types.js";
+
+type event = <K extends EventType>(
+	eventType: K,
+	listener: EventListener<K>
+) => SubmitReturn;
+type predict = (
+	endpoint: string | number,
+	data?: unknown[],
+	event_data?: unknown
+) => Promise<unknown>;
+
+type client_return = {
+	predict: predict;
+	config: Config;
+	submit: (
+		endpoint: string | number,
+		data?: unknown[],
+		event_data?: unknown
+	) => SubmitReturn;
+	view_api: (c?: Config) => Promise<ApiInfo<JsApiData>>;
+};
+
+type SubmitReturn = {
+	on: event;
+	off: event;
+	cancel: () => Promise<void>;
+	destroy: () => void;
+};
+
+const QUEUE_FULL_MSG = "This application is too busy. Keep trying!";
+const BROKEN_CONNECTION_MSG = "Connection errored out.";
+
+export let NodeBlob;
+
+export async function duplicate(
+	app_reference: string,
+	options: {
+		hf_token: `hf_${string}`;
+		private?: boolean;
+		status_callback: SpaceStatusCallback;
+		hardware?: (typeof hardware_types)[number];
+		timeout?: number;
+	}
+): Promise<client_return> {
+	const { hf_token, private: _private, hardware, timeout } = options;
+
+	if (hardware && !hardware_types.includes(hardware)) {
+		throw new Error(
+			`Invalid hardware type provided. Valid types are: ${hardware_types
+				.map((v) => `"${v}"`)
+				.join(",")}.`
+		);
+	}
+	const headers = {
+		Authorization: `Bearer ${hf_token}`
+	};
+
+	const user = (
+		await (
+			await fetch(`https://huggingface.co/api/whoami-v2`, {
+				headers
+			})
+		).json()
+	).name;
+
+	const space_name = app_reference.split("/")[1];
+	const body: {
+		repository: string;
+		private?: boolean;
+	} = {
+		repository: `${user}/${space_name}`
+	};
+
+	if (_private) {
+		body.private = true;
+	}
+
+	try {
+		const response = await fetch(
+			`https://huggingface.co/api/spaces/${app_reference}/duplicate`,
+			{
+				method: "POST",
+				headers: { "Content-Type": "application/json", ...headers },
+				body: JSON.stringify(body)
+			}
+		);
+
+		if (response.status === 409) {
+			return client(`${user}/${space_name}`, options);
+		}
+		const duplicated_space = await response.json();
+
+		let original_hardware;
+
+		if (!hardware) {
+			original_hardware = await get_space_hardware(app_reference, hf_token);
+		}
+
+		const requested_hardware = hardware || original_hardware || "cpu-basic";
+		await set_space_hardware(
+			`${user}/${space_name}`,
+			requested_hardware,
+			hf_token
+		);
+
+		await set_space_timeout(`${user}/${space_name}`, timeout || 300, hf_token);
+		return client(duplicated_space.url, options);
+	} catch (e: any) {
+		throw new Error(e);
+	}
+}
+
+interface Client {
+	post_data: (
+		url: string,
+		body: unknown,
+		token?: `hf_${string}`
+	) => Promise<[PostResponse, number]>;
+	upload_files: (
+		root: string,
+		files: File[],
+		token?: `hf_${string}`
+	) => Promise<UploadResponse>;
+	client: (
+		app_reference: string,
+		options: {
+			hf_token?: `hf_${string}`;
+			status_callback?: SpaceStatusCallback;
+			normalise_files?: boolean;
+		}
+	) => Promise<client_return>;
+	handle_blob: (
+		endpoint: string,
+		data: unknown[],
+		api_info: ApiInfo<JsApiData>,
+		token?: `hf_${string}`
+	) => Promise<unknown[]>;
+}
+
+export function api_factory(fetch_implementation: typeof fetch): Client {
+	return { post_data, upload_files, client, handle_blob };
+
+	async function post_data(
+		url: string,
+		body: unknown,
+		token?: `hf_${string}`
+	): Promise<[PostResponse, number]> {
+		const headers: {
+			Authorization?: string;
+			"Content-Type": "application/json";
+		} = { "Content-Type": "application/json" };
+		if (token) {
+			headers.Authorization = `Bearer ${token}`;
+		}
+		try {
+			var response = await fetch_implementation(url, {
+				method: "POST",
+				body: JSON.stringify(body),
+				headers
+			});
+		} catch (e) {
+			return [{ error: BROKEN_CONNECTION_MSG }, 500];
+		}
+		const output: PostResponse = await response.json();
+		return [output, response.status];
+	}
+
+	async function upload_files(
+		root: string,
+		files: (Blob | File)[],
+		token?: `hf_${string}`
+	): Promise<UploadResponse> {
+		const headers: {
+			Authorization?: string;
+		} = {};
+		if (token) {
+			headers.Authorization = `Bearer ${token}`;
+		}
+		const chunkSize = 1000;
+		const uploadResponses = [];
+		for (let i = 0; i < files.length; i += chunkSize) {
+			const chunk = files.slice(i, i + chunkSize);
+			const formData = new FormData();
+			chunk.forEach((file) => {
+				formData.append("files", file);
+			});
+			try {
+				var response = await fetch_implementation(`${root}/upload`, {
+					method: "POST",
+					body: formData,
+					headers
+				});
+			} catch (e) {
+				return { error: BROKEN_CONNECTION_MSG };
+			}
+			const output: UploadResponse["files"] = await response.json();
+			uploadResponses.push(...output);
+		}
+		return { files: uploadResponses };
+	}
+
+	async function client(
+		app_reference: string,
+		options: {
+			hf_token?: `hf_${string}`;
+			status_callback?: SpaceStatusCallback;
+			normalise_files?: boolean;
+		} = { normalise_files: true }
+	): Promise<client_return> {
+		return new Promise(async (res) => {
+			const { status_callback, hf_token, normalise_files } = options;
+			const return_obj = {
+				predict,
+				submit,
+				view_api
+				// duplicate
+			};
+
+			const transform_files = normalise_files ?? true;
+			if (typeof window === "undefined" || !("WebSocket" in window)) {
+				const ws = await import("ws");
+				NodeBlob = (await import("node:buffer")).Blob;
+				//@ts-ignore
+				global.WebSocket = ws.WebSocket;
+			}
+
+			const { ws_protocol, http_protocol, host, space_id } =
+				await process_endpoint(app_reference, hf_token);
+
+			const session_hash = Math.random().toString(36).substring(2);
+			const last_status: Record<string, Status["stage"]> = {};
+			let config: Config;
+			let api_map: Record<string, number> = {};
+
+			let jwt: false | string = false;
+
+			if (hf_token && space_id) {
+				jwt = await get_jwt(space_id, hf_token);
+			}
+
+			async function config_success(_config: Config): Promise<client_return> {
+				config = _config;
+				api_map = map_names_to_ids(_config?.dependencies || []);
+				if (config.auth_required) {
+					return {
+						config,
+						...return_obj
+					};
+				}
+				try {
+					api = await view_api(config);
+				} catch (e) {
+					console.error(`Could not get api details: ${e.message}`);
+				}
+
+				return {
+					config,
+					...return_obj
+				};
+			}
+			let api: ApiInfo<JsApiData>;
+			async function handle_space_sucess(status: SpaceStatus): Promise<void> {
+				if (status_callback) status_callback(status);
+				if (status.status === "running")
+					try {
+						config = await resolve_config(
+							fetch_implementation,
+							`${http_protocol}//${host}`,
+							hf_token
+						);
+
+						const _config = await config_success(config);
+						res(_config);
+					} catch (e) {
+						console.error(e);
+						if (status_callback) {
+							status_callback({
+								status: "error",
+								message: "Could not load this space.",
+								load_status: "error",
+								detail: "NOT_FOUND"
+							});
+						}
+					}
+			}
+
+			try {
+				config = await resolve_config(
+					fetch_implementation,
+					`${http_protocol}//${host}`,
+					hf_token
+				);
+
+				const _config = await config_success(config);
+				res(_config);
+			} catch (e) {
+				console.error(e);
+				if (space_id) {
+					check_space_status(
+						space_id,
+						RE_SPACE_NAME.test(space_id) ? "space_name" : "subdomain",
+						handle_space_sucess
+					);
+				} else {
+					if (status_callback)
+						status_callback({
+							status: "error",
+							message: "Could not load this space.",
+							load_status: "error",
+							detail: "NOT_FOUND"
+						});
+				}
+			}
+
+			function predict(
+				endpoint: string,
+				data: unknown[],
+				event_data?: unknown
+			): Promise<unknown> {
+				let data_returned = false;
+				let status_complete = false;
+				let dependency;
+				if (typeof endpoint === "number") {
+					dependency = config.dependencies[endpoint];
+				} else {
+					const trimmed_endpoint = endpoint.replace(/^\//, "");
+					dependency = config.dependencies[api_map[trimmed_endpoint]];
+				}
+
+				if (dependency.types.continuous) {
+					throw new Error(
+						"Cannot call predict on this function as it may run forever. Use submit instead"
+					);
+				}
+
+				return new Promise((res, rej) => {
+					const app = submit(endpoint, data, event_data);
+					let result;
+
+					app
+						.on("data", (d) => {
+							// if complete message comes before data, resolve here
+							if (status_complete) {
+								app.destroy();
+								res(d);
+							}
+							data_returned = true;
+							result = d;
+						})
+						.on("status", (status) => {
+							if (status.stage === "error") rej(status);
+							if (status.stage === "complete") {
+								status_complete = true;
+								app.destroy();
+								// if complete message comes after data, resolve here
+								if (data_returned) {
+									res(result);
+								}
+							}
+						});
+				});
+			}
+
+			function submit(
+				endpoint: string | number,
+				data: unknown[],
+				event_data?: unknown
+			): SubmitReturn {
+				let fn_index: number;
+				let api_info;
+
+				if (typeof endpoint === "number") {
+					fn_index = endpoint;
+					api_info = api.unnamed_endpoints[fn_index];
+				} else {
+					const trimmed_endpoint = endpoint.replace(/^\//, "");
+
+					fn_index = api_map[trimmed_endpoint];
+					api_info = api.named_endpoints[endpoint.trim()];
+				}
+
+				if (typeof fn_index !== "number") {
+					throw new Error(
+						"There is no endpoint matching that name of fn_index matching that number."
+					);
+				}
+
+				let websocket: WebSocket;
+
+				const _endpoint = typeof endpoint === "number" ? "/predict" : endpoint;
+				let payload: Payload;
+				let complete: false | Record<string, any> = false;
+				const listener_map: ListenerMap<EventType> = {};
+				const url_params = new URLSearchParams(
+					window.location.search
+				).toString();
+
+				handle_blob(
+					`${http_protocol}//${host + config.path}`,
+					data,
+					api_info,
+					hf_token
+				).then((_payload) => {
+					payload = { data: _payload || [], event_data, fn_index };
+					if (skip_queue(fn_index, config)) {
+						fire_event({
+							type: "status",
+							endpoint: _endpoint,
+							stage: "pending",
+							queue: false,
+							fn_index,
+							time: new Date()
+						});
+
+						post_data(
+							`${http_protocol}//${host + config.path}/run${
+								_endpoint.startsWith("/") ? _endpoint : `/${_endpoint}`
+							}${url_params ? "?" + url_params : ""}`,
+							{
+								...payload,
+								session_hash
+							},
+							hf_token
+						)
+							.then(([output, status_code]) => {
+								const data = transform_files
+									? transform_output(
+											output.data,
+											api_info,
+											config.root,
+											config.root_url
+									  )
+									: output.data;
+								if (status_code == 200) {
+									fire_event({
+										type: "data",
+										endpoint: _endpoint,
+										fn_index,
+										data: data,
+										time: new Date()
+									});
+
+									fire_event({
+										type: "status",
+										endpoint: _endpoint,
+										fn_index,
+										stage: "complete",
+										eta: output.average_duration,
+										queue: false,
+										time: new Date()
+									});
+								} else {
+									fire_event({
+										type: "status",
+										stage: "error",
+										endpoint: _endpoint,
+										fn_index,
+										message: output.error,
+										queue: false,
+										time: new Date()
+									});
+								}
+							})
+							.catch((e) => {
+								fire_event({
+									type: "status",
+									stage: "error",
+									message: e.message,
+									endpoint: _endpoint,
+									fn_index,
+									queue: false,
+									time: new Date()
+								});
+							});
+					} else {
+						fire_event({
+							type: "status",
+							stage: "pending",
+							queue: true,
+							endpoint: _endpoint,
+							fn_index,
+							time: new Date()
+						});
+
+						let url = new URL(`${ws_protocol}://${host}${config.path}
+							/queue/join${url_params ? "?" + url_params : ""}`);
+
+						if (jwt) {
+							url.searchParams.set("__sign", jwt);
+						}
+
+						websocket = new WebSocket(url);
+
+						websocket.onclose = (evt) => {
+							if (!evt.wasClean) {
+								fire_event({
+									type: "status",
+									stage: "error",
+									broken: true,
+									message: BROKEN_CONNECTION_MSG,
+									queue: true,
+									endpoint: _endpoint,
+									fn_index,
+									time: new Date()
+								});
+							}
+						};
+
+						websocket.onmessage = function (event) {
+							const _data = JSON.parse(event.data);
+							const { type, status, data } = handle_message(
+								_data,
+								last_status[fn_index]
+							);
+
+							if (type === "update" && status && !complete) {
+								// call 'status' listeners
+								fire_event({
+									type: "status",
+									endpoint: _endpoint,
+									fn_index,
+									time: new Date(),
+									...status
+								});
+								if (status.stage === "error") {
+									websocket.close();
+								}
+							} else if (type === "hash") {
+								websocket.send(JSON.stringify({ fn_index, session_hash }));
+								return;
+							} else if (type === "data") {
+								websocket.send(JSON.stringify({ ...payload, session_hash }));
+							} else if (type === "complete") {
+								complete = status;
+							} else if (type === "log") {
+								fire_event({
+									type: "log",
+									log: data.log,
+									level: data.level,
+									endpoint: _endpoint,
+									fn_index
+								});
+							} else if (type === "generating") {
+								fire_event({
+									type: "status",
+									time: new Date(),
+									...status,
+									stage: status?.stage!,
+									queue: true,
+									endpoint: _endpoint,
+									fn_index
+								});
+							}
+							if (data) {
+								fire_event({
+									type: "data",
+									time: new Date(),
+									data: transform_files
+										? transform_output(
+												data.data,
+												api_info,
+												config.root,
+												config.root_url
+										  )
+										: data.data,
+									endpoint: _endpoint,
+									fn_index
+								});
+
+								if (complete) {
+									fire_event({
+										type: "status",
+										time: new Date(),
+										...complete,
+										stage: status?.stage!,
+										queue: true,
+										endpoint: _endpoint,
+										fn_index
+									});
+									websocket.close();
+								}
+							}
+						};
+
+						// different ws contract for gradio versions older than 3.6.0
+						//@ts-ignore
+						if (semiver(config.version || "2.0.0", "3.6") < 0) {
+							addEventListener("open", () =>
+								websocket.send(JSON.stringify({ hash: session_hash }))
+							);
+						}
+					}
+				});
+
+				function fire_event<K extends EventType>(event: Event<K>): void {
+					const narrowed_listener_map: ListenerMap<K> = listener_map;
+					const listeners = narrowed_listener_map[event.type] || [];
+					listeners?.forEach((l) => l(event));
+				}
+
+				function on<K extends EventType>(
+					eventType: K,
+					listener: EventListener<K>
+				): SubmitReturn {
+					const narrowed_listener_map: ListenerMap<K> = listener_map;
+					const listeners = narrowed_listener_map[eventType] || [];
+					narrowed_listener_map[eventType] = listeners;
+					listeners?.push(listener);
+
+					return { on, off, cancel, destroy };
+				}
+
+				function off<K extends EventType>(
+					eventType: K,
+					listener: EventListener<K>
+				): SubmitReturn {
+					const narrowed_listener_map: ListenerMap<K> = listener_map;
+					let listeners = narrowed_listener_map[eventType] || [];
+					listeners = listeners?.filter((l) => l !== listener);
+					narrowed_listener_map[eventType] = listeners;
+
+					return { on, off, cancel, destroy };
+				}
+
+				async function cancel(): Promise<void> {
+					const _status: Status = {
+						stage: "complete",
+						queue: false,
+						time: new Date()
+					};
+					complete = _status;
+					fire_event({
+						..._status,
+						type: "status",
+						endpoint: _endpoint,
+						fn_index: fn_index
+					});
+
+					if (websocket && websocket.readyState === 0) {
+						websocket.addEventListener("open", () => {
+							websocket.close();
+						});
+					} else {
+						websocket.close();
+					}
+
+					try {
+						await fetch_implementation(
+							`${http_protocol}//${host + config.path}/reset`,
+							{
+								headers: { "Content-Type": "application/json" },
+								method: "POST",
+								body: JSON.stringify({ fn_index, session_hash })
+							}
+						);
+					} catch (e) {
+						console.warn(
+							"The `/reset` endpoint could not be called. Subsequent endpoint results may be unreliable."
+						);
+					}
+				}
+
+				function destroy(): void {
+					for (const event_type in listener_map) {
+						listener_map[event_type as "data" | "status"].forEach((fn) => {
+							off(event_type as "data" | "status", fn);
+						});
+					}
+				}
+
+				return {
+					on,
+					off,
+					cancel,
+					destroy
+				};
+			}
+
+			async function view_api(config?: Config): Promise<ApiInfo<JsApiData>> {
+				if (api) return api;
+
+				const headers: {
+					Authorization?: string;
+					"Content-Type": "application/json";
+				} = { "Content-Type": "application/json" };
+				if (hf_token) {
+					headers.Authorization = `Bearer ${hf_token}`;
+				}
+				let response: Response;
+				// @ts-ignore
+				if (semiver(config.version || "2.0.0", "3.30") < 0) {
+					response = await fetch_implementation(
+						"https://gradio-space-api-fetcher-v2.hf.space/api",
+						{
+							method: "POST",
+							body: JSON.stringify({
+								serialize: false,
+								config: JSON.stringify(config)
+							}),
+							headers
+						}
+					);
+				} else {
+					response = await fetch_implementation(`${config.root}/info`, {
+						headers
+					});
+				}
+
+				if (!response.ok) {
+					throw new Error(BROKEN_CONNECTION_MSG);
+				}
+
+				let api_info = (await response.json()) as
+					| ApiInfo<ApiData>
+					| { api: ApiInfo<ApiData> };
+				if ("api" in api_info) {
+					api_info = api_info.api;
+				}
+
+				if (
+					api_info.named_endpoints["/predict"] &&
+					!api_info.unnamed_endpoints["0"]
+				) {
+					api_info.unnamed_endpoints[0] = api_info.named_endpoints["/predict"];
+				}
+
+				const x = transform_api_info(api_info, config, api_map);
+				return x;
+			}
+		});
+	}
+
+	async function handle_blob(
+		endpoint: string,
+		data: unknown[],
+		api_info: ApiInfo<JsApiData>,
+		token?: `hf_${string}`
+	): Promise<unknown[]> {
+		const blob_refs = await walk_and_store_blobs(
+			data,
+			undefined,
+			[],
+			true,
+			api_info
+		);
+
+		return Promise.all(
+			blob_refs.map(async ({ path, blob, data, type }) => {
+				if (blob) {
+					const file_url = (await upload_files(endpoint, [blob], token))
+						.files[0];
+					return { path, file_url, type };
+				}
+				return { path, base64: data, type };
+			})
+		).then((r) => {
+			r.forEach(({ path, file_url, base64, type }) => {
+				if (base64) {
+					update_object(data, base64, path);
+				} else if (type === "Gallery") {
+					update_object(data, file_url, path);
+				} else if (file_url) {
+					const o = {
+						is_file: true,
+						name: `${file_url}`,
+						data: null
+						// orig_name: "file.csv"
+					};
+					update_object(data, o, path);
+				}
+			});
+
+			return data;
+		});
+	}
+}
+
+export const { post_data, upload_files, client, handle_blob } =
+	api_factory(fetch);
+
+function transform_output(
+	data: any[],
+	api_info: any,
+	root_url: string,
+	remote_url?: string
+): unknown[] {
+	return data.map((d, i) => {
+		if (api_info?.returns?.[i]?.component === "File") {
+			return normalise_file(d, root_url, remote_url);
+		} else if (api_info?.returns?.[i]?.component === "Gallery") {
+			return d.map((img) => {
+				return Array.isArray(img)
+					? [normalise_file(img[0], root_url, remote_url), img[1]]
+					: [normalise_file(img, root_url, remote_url), null];
+			});
+		} else if (typeof d === "object" && d?.is_file) {
+			return normalise_file(d, root_url, remote_url);
+		}
+		return d;
+	});
+}
+
+function normalise_file(
+	file: FileData[],
+	root: string,
+	root_url: string | null
+): FileData[];
+function normalise_file(
+	file: FileData | string,
+	root: string,
+	root_url: string | null
+): FileData;
+function normalise_file(
+	file: null,
+	root: string,
+	root_url: string | null
+): null;
+function normalise_file(file, root, root_url): FileData[] | FileData | null {
+	if (file == null) return null;
+	if (typeof file === "string") {
+		return {
+			name: "file_data",
+			data: file
+		};
+	} else if (Array.isArray(file)) {
+		const normalized_file: (FileData | null)[] = [];
+
+		for (const x of file) {
+			if (x === null) {
+				normalized_file.push(null);
+			} else {
+				normalized_file.push(normalise_file(x, root, root_url));
+			}
+		}
+
+		return normalized_file as FileData[];
+	} else if (file.is_file) {
+		if (!root_url) {
+			file.data = root + "/file=" + file.name;
+		} else {
+			file.data = "/proxy=" + root_url + "file=" + file.name;
+		}
+	}
+	return file;
+}
+
+interface ApiData {
+	label: string;
+	type: {
+		type: any;
+		description: string;
+	};
+	component: string;
+	example_input?: any;
+}
+
+interface JsApiData {
+	label: string;
+	type: string;
+	component: string;
+	example_input: any;
+}
+
+interface EndpointInfo<T extends ApiData | JsApiData> {
+	parameters: T[];
+	returns: T[];
+}
+interface ApiInfo<T extends ApiData | JsApiData> {
+	named_endpoints: {
+		[key: string]: EndpointInfo<T>;
+	};
+	unnamed_endpoints: {
+		[key: string]: EndpointInfo<T>;
+	};
+}
+
+function get_type(
+	type: { [key: string]: any },
+	component: string,
+	serializer: string,
+	signature_type: "return" | "parameter"
+): string {
+	switch (type.type) {
+		case "string":
+			return "string";
+		case "boolean":
+			return "boolean";
+		case "number":
+			return "number";
+	}
+
+	if (
+		serializer === "JSONSerializable" ||
+		serializer === "StringSerializable"
+	) {
+		return "any";
+	} else if (serializer === "ListStringSerializable") {
+		return "string[]";
+	} else if (component === "Image") {
+		return signature_type === "parameter" ? "Blob | File | Buffer" : "string";
+	} else if (serializer === "FileSerializable") {
+		if (type?.type === "array") {
+			return signature_type === "parameter"
+				? "(Blob | File | Buffer)[]"
+				: `{ name: string; data: string; size?: number; is_file?: boolean; orig_name?: string}[]`;
+		}
+		return signature_type === "parameter"
+			? "Blob | File | Buffer"
+			: `{ name: string; data: string; size?: number; is_file?: boolean; orig_name?: string}`;
+	} else if (serializer === "GallerySerializable") {
+		return signature_type === "parameter"
+			? "[(Blob | File | Buffer), (string | null)][]"
+			: `[{ name: string; data: string; size?: number; is_file?: boolean; orig_name?: string}, (string | null))][]`;
+	}
+}
+
+function get_description(
+	type: { type: any; description: string },
+	serializer: string
+): string {
+	if (serializer === "GallerySerializable") {
+		return "array of [file, label] tuples";
+	} else if (serializer === "ListStringSerializable") {
+		return "array of strings";
+	} else if (serializer === "FileSerializable") {
+		return "array of files or single file";
+	}
+	return type.description;
+}
+
+function transform_api_info(
+	api_info: ApiInfo<ApiData>,
+	config: Config,
+	api_map: Record<string, number>
+): ApiInfo<JsApiData> {
+	const new_data = {
+		named_endpoints: {},
+		unnamed_endpoints: {}
+	};
+	for (const key in api_info) {
+		const cat = api_info[key];
+
+		for (const endpoint in cat) {
+			const dep_index = config.dependencies[endpoint]
+				? endpoint
+				: api_map[endpoint.replace("/", "")];
+
+			const info = cat[endpoint];
+			new_data[key][endpoint] = {};
+			new_data[key][endpoint].parameters = {};
+			new_data[key][endpoint].returns = {};
+			new_data[key][endpoint].type = config.dependencies[dep_index].types;
+			new_data[key][endpoint].parameters = info.parameters.map(
+				({ label, component, type, serializer }) => ({
+					label,
+					component,
+					type: get_type(type, component, serializer, "parameter"),
+					description: get_description(type, serializer)
+				})
+			);
+
+			new_data[key][endpoint].returns = info.returns.map(
+				({ label, component, type, serializer }) => ({
+					label,
+					component,
+					type: get_type(type, component, serializer, "return"),
+					description: get_description(type, serializer)
+				})
+			);
+		}
+	}
+
+	return new_data;
+}
+
+async function get_jwt(
+	space: string,
+	token: `hf_${string}`
+): Promise<string | false> {
+	try {
+		const r = await fetch(`https://huggingface.co/api/spaces/${space}/jwt`, {
+			headers: {
+				Authorization: `Bearer ${token}`
+			}
+		});
+
+		const jwt = (await r.json()).token;
+
+		return jwt || false;
+	} catch (e) {
+		console.error(e);
+		return false;
+	}
+}
+
+function update_object(object, newValue, stack): void {
+	while (stack.length > 1) {
+		object = object[stack.shift()];
+	}
+
+	object[stack.shift()] = newValue;
+}
+
+export async function walk_and_store_blobs(
+	param,
+	type = undefined,
+	path = [],
+	root = false,
+	api_info = undefined
+): Promise<
+	{
+		path: string[];
+		data: string | false;
+		type: string;
+		blob: Blob | false;
+	}[]
+> {
+	if (Array.isArray(param)) {
+		let blob_refs = [];
+
+		await Promise.all(
+			param.map(async (v, i) => {
+				let new_path = path.slice();
+				new_path.push(i);
+
+				const array_refs = await walk_and_store_blobs(
+					param[i],
+					root ? api_info?.parameters[i]?.component || undefined : type,
+					new_path,
+					false,
+					api_info
+				);
+
+				blob_refs = blob_refs.concat(array_refs);
+			})
+		);
+
+		return blob_refs;
+	} else if (globalThis.Buffer && param instanceof globalThis.Buffer) {
+		const is_image = type === "Image";
+		return [
+			{
+				path: path,
+				blob: is_image ? false : new NodeBlob([param]),
+				data: is_image ? `${param.toString("base64")}` : false,
+				type
+			}
+		];
+	} else if (
+		param instanceof Blob ||
+		(typeof window !== "undefined" && param instanceof File)
+	) {
+		if (type === "Image") {
+			let data;
+
+			if (typeof window !== "undefined") {
+				// browser
+				data = await image_to_data_uri(param);
+			} else {
+				const buffer = await param.arrayBuffer();
+				data = Buffer.from(buffer).toString("base64");
+			}
+
+			return [{ path, data, type, blob: false }];
+		}
+		return [{ path: path, blob: param, type, data: false }];
+	} else if (typeof param === "object") {
+		let blob_refs = [];
+		for (let key in param) {
+			if (param.hasOwnProperty(key)) {
+				let new_path = path.slice();
+				new_path.push(key);
+				blob_refs = blob_refs.concat(
+					await walk_and_store_blobs(
+						param[key],
+						undefined,
+						new_path,
+						false,
+						api_info
+					)
+				);
+			}
+		}
+		return blob_refs;
+	}
+	return [];
+}
+
+function image_to_data_uri(blob: Blob): Promise<string | ArrayBuffer> {
+	return new Promise((resolve, _) => {
+		const reader = new FileReader();
+		reader.onloadend = () => resolve(reader.result);
+		reader.readAsDataURL(blob);
+	});
+}
+
+function skip_queue(id: number, config: Config): boolean {
+	return (
+		!(config?.dependencies?.[id]?.queue === null
+			? config.enable_queue
+			: config?.dependencies?.[id]?.queue) || false
+	);
+}
+
+async function resolve_config(
+	fetch_implementation: typeof fetch,
+	endpoint?: string,
+	token?: `hf_${string}`
+): Promise<Config> {
+	const headers: { Authorization?: string } = {};
+	if (token) {
+		headers.Authorization = `Bearer ${token}`;
+	}
+	if (
+		typeof window !== "undefined" &&
+		window.gradio_config &&
+		location.origin !== "http://localhost:9876" &&
+		!window.gradio_config.dev_mode
+	) {
+		const path = window.gradio_config.root;
+		const config = window.gradio_config;
+		config.root = endpoint + config.root;
+		return { ...config, path: path };
+	} else if (endpoint) {
+		let response = await fetch_implementation(`${endpoint}/config`, {
+			headers
+		});
+
+		if (response.status === 200) {
+			const config = await response.json();
+			config.path = config.path ?? "";
+			config.root = endpoint;
+			return config;
+		}
+		throw new Error("Could not get config.");
+	}
+
+	throw new Error("No config or app endpoint found");
+}
+
+async function check_space_status(
+	id: string,
+	type: "subdomain" | "space_name",
+	status_callback: SpaceStatusCallback
+): Promise<void> {
+	let endpoint =
+		type === "subdomain"
+			? `https://huggingface.co/api/spaces/by-subdomain/${id}`
+			: `https://huggingface.co/api/spaces/${id}`;
+	let response;
+	let _status;
+	try {
+		response = await fetch(endpoint);
+		_status = response.status;
+		if (_status !== 200) {
+			throw new Error();
+		}
+		response = await response.json();
+	} catch (e) {
+		status_callback({
+			status: "error",
+			load_status: "error",
+			message: "Could not get space status",
+			detail: "NOT_FOUND"
+		});
+		return;
+	}
+
+	if (!response || _status !== 200) return;
+	const {
+		runtime: { stage },
+		id: space_name
+	} = response;
+
+	switch (stage) {
+		case "STOPPED":
+		case "SLEEPING":
+			status_callback({
+				status: "sleeping",
+				load_status: "pending",
+				message: "Space is asleep. Waking it up...",
+				detail: stage
+			});
+
+			setTimeout(() => {
+				check_space_status(id, type, status_callback);
+			}, 1000); // poll for status
+			break;
+		case "PAUSED":
+			status_callback({
+				status: "paused",
+				load_status: "error",
+				message:
+					"This space has been paused by the author. If you would like to try this demo, consider duplicating the space.",
+				detail: stage,
+				discussions_enabled: await discussions_enabled(space_name)
+			});
+			break;
+		case "RUNNING":
+		case "RUNNING_BUILDING":
+			status_callback({
+				status: "running",
+				load_status: "complete",
+				message: "",
+				detail: stage
+			});
+			// load_config(source);
+			//  launch
+			break;
+		case "BUILDING":
+			status_callback({
+				status: "building",
+				load_status: "pending",
+				message: "Space is building...",
+				detail: stage
+			});
+
+			setTimeout(() => {
+				check_space_status(id, type, status_callback);
+			}, 1000);
+			break;
+		default:
+			status_callback({
+				status: "space_error",
+				load_status: "error",
+				message: "This space is experiencing an issue.",
+				detail: stage,
+				discussions_enabled: await discussions_enabled(space_name)
+			});
+			break;
+	}
+}
+
+function handle_message(
+	data: any,
+	last_status: Status["stage"]
+): {
+	type: "hash" | "data" | "update" | "complete" | "generating" | "log" | "none";
+	data?: any;
+	status?: Status;
+} {
+	const queue = true;
+	switch (data.msg) {
+		case "send_data":
+			return { type: "data" };
+		case "send_hash":
+			return { type: "hash" };
+		case "queue_full":
+			return {
+				type: "update",
+				status: {
+					queue,
+					message: QUEUE_FULL_MSG,
+					stage: "error",
+					code: data.code,
+					success: data.success
+				}
+			};
+		case "estimation":
+			return {
+				type: "update",
+				status: {
+					queue,
+					stage: last_status || "pending",
+					code: data.code,
+					size: data.queue_size,
+					position: data.rank,
+					eta: data.rank_eta,
+					success: data.success
+				}
+			};
+		case "progress":
+			return {
+				type: "update",
+				status: {
+					queue,
+					stage: "pending",
+					code: data.code,
+					progress_data: data.progress_data,
+					success: data.success
+				}
+			};
+		case "log":
+			return { type: "log", data: data };
+		case "process_generating":
+			return {
+				type: "generating",
+				status: {
+					queue,
+					message: !data.success ? data.output.error : null,
+					stage: data.success ? "generating" : "error",
+					code: data.code,
+					progress_data: data.progress_data,
+					eta: data.average_duration
+				},
+				data: data.success ? data.output : null
+			};
+		case "process_completed":
+			if ("error" in data.output) {
+				return {
+					type: "update",
+					status: {
+						queue,
+						message: data.output.error as string,
+						stage: "error",
+						code: data.code,
+						success: data.success
+					}
+				};
+			}
+			return {
+				type: "complete",
+				status: {
+					queue,
+					message: !data.success ? data.output.error : undefined,
+					stage: data.success ? "complete" : "error",
+					code: data.code,
+					progress_data: data.progress_data,
+					eta: data.output.average_duration
+				},
+				data: data.success ? data.output : null
+			};
+
+		case "process_starts":
+			return {
+				type: "update",
+				status: {
+					queue,
+					stage: "pending",
+					code: data.code,
+					size: data.rank,
+					position: 0,
+					success: data.success
+				}
+			};
+	}
+
+	return { type: "none", status: { stage: "error", queue } };
+}

testbed/gradio-app__gradio/client/js/src/globals.d.ts

@@ -0,0 +1,29 @@
+declare global {
+	interface Window {
+		__gradio_mode__: "app" | "website";
+		gradio_config: Config;
+		__is_colab__: boolean;
+		__gradio_space__: string | null;
+	}
+}
+
+export interface Config {
+	auth_required: boolean | undefined;
+	auth_message: string;
+	components: any[];
+	css: string | null;
+	dependencies: any[];
+	dev_mode: boolean;
+	enable_queue: boolean;
+	layout: any;
+	mode: "blocks" | "interface";
+	root: string;
+	theme: string;
+	title: string;
+	version: string;
+	space_id: string | null;
+	is_colab: boolean;
+	show_api: boolean;
+	stylesheets: string[];
+	path: string;
+}

testbed/gradio-app__gradio/client/js/src/index.ts

@@ -0,0 +1,8 @@
+export {
+	client,
+	post_data,
+	upload_files,
+	duplicate,
+	api_factory
+} from "./client.js";
+export type { SpaceStatus } from "./types.js";

testbed/gradio-app__gradio/client/js/src/types.ts

@@ -0,0 +1,116 @@
+export interface Config {
+	auth_required: boolean | undefined;
+	auth_message: string;
+	components: any[];
+	css: string | null;
+	dependencies: any[];
+	dev_mode: boolean;
+	enable_queue: boolean;
+	layout: any;
+	mode: "blocks" | "interface";
+	root: string;
+	root_url?: string;
+	theme: string;
+	title: string;
+	version: string;
+	space_id: string | null;
+	is_colab: boolean;
+	show_api: boolean;
+	stylesheets: string[];
+	path: string;
+}
+
+export interface Payload {
+	data: unknown[];
+	fn_index?: number;
+	event_data?: unknown;
+	time?: Date;
+}
+
+export interface PostResponse {
+	error?: string;
+	[x: string]: any;
+}
+export interface UploadResponse {
+	error?: string;
+	files?: string[];
+}
+
+export interface Status {
+	queue: boolean;
+	code?: string;
+	success?: boolean;
+	stage: "pending" | "error" | "complete" | "generating";
+	broken?: boolean;
+	size?: number;
+	position?: number;
+	eta?: number;
+	message?: string;
+	progress_data?: {
+		progress: number | null;
+		index: number | null;
+		length: number | null;
+		unit: string | null;
+		desc: string | null;
+	}[];
+	time?: Date;
+}
+
+export interface LogMessage {
+	log: string;
+	level: "warning" | "info";
+}
+
+export interface SpaceStatusNormal {
+	status: "sleeping" | "running" | "building" | "error" | "stopped";
+	detail:
+		| "SLEEPING"
+		| "RUNNING"
+		| "RUNNING_BUILDING"
+		| "BUILDING"
+		| "NOT_FOUND";
+	load_status: "pending" | "error" | "complete" | "generating";
+	message: string;
+}
+export interface SpaceStatusError {
+	status: "space_error" | "paused";
+	detail:
+		| "NO_APP_FILE"
+		| "CONFIG_ERROR"
+		| "BUILD_ERROR"
+		| "RUNTIME_ERROR"
+		| "PAUSED";
+	load_status: "error";
+	message: string;
+	discussions_enabled: boolean;
+}
+export type SpaceStatus = SpaceStatusNormal | SpaceStatusError;
+
+export type status_callback_function = (a: Status) => void;
+export type SpaceStatusCallback = (a: SpaceStatus) => void;
+
+export type EventType = "data" | "status" | "log";
+
+export interface EventMap {
+	data: Payload;
+	status: Status;
+	log: LogMessage;
+}
+
+export type Event<K extends EventType> = {
+	[P in K]: EventMap[P] & { type: P; endpoint: string; fn_index: number };
+}[K];
+export type EventListener<K extends EventType> = (event: Event<K>) => void;
+export type ListenerMap<K extends EventType> = {
+	[P in K]?: EventListener<K>[];
+};
+export interface FileData {
+	name: string;
+	orig_name?: string;
+	size?: number;
+	data: string;
+	blob?: File;
+	is_file?: boolean;
+	mime_type?: string;
+	alt_text?: string;
+}

testbed/gradio-app__gradio/client/js/src/utils.ts

@@ -0,0 +1,212 @@
+import type { Config } from "./types.js";
+
+export function determine_protocol(endpoint: string): {
+	ws_protocol: "ws" | "wss";
+	http_protocol: "http:" | "https:";
+	host: string;
+} {
+	if (endpoint.startsWith("http")) {
+		const { protocol, host } = new URL(endpoint);
+
+		if (host.endsWith("hf.space")) {
+			return {
+				ws_protocol: "wss",
+				host: host,
+				http_protocol: protocol as "http:" | "https:"
+			};
+		}
+		return {
+			ws_protocol: protocol === "https:" ? "wss" : "ws",
+			http_protocol: protocol as "http:" | "https:",
+			host
+		};
+	}
+
+	// default to secure if no protocol is provided
+	return {
+		ws_protocol: "wss",
+		http_protocol: "https:",
+		host: endpoint
+	};
+}
+
+export const RE_SPACE_NAME = /^[^\/]*\/[^\/]*$/;
+export const RE_SPACE_DOMAIN = /.*hf\.space\/{0,1}$/;
+export async function process_endpoint(
+	app_reference: string,
+	token?: `hf_${string}`
+): Promise<{
+	space_id: string | false;
+	host: string;
+	ws_protocol: "ws" | "wss";
+	http_protocol: "http:" | "https:";
+}> {
+	const headers: { Authorization?: string } = {};
+	if (token) {
+		headers.Authorization = `Bearer ${token}`;
+	}
+
+	const _app_reference = app_reference.trim();
+
+	if (RE_SPACE_NAME.test(_app_reference)) {
+		try {
+			const res = await fetch(
+				`https://huggingface.co/api/spaces/${_app_reference}/host`,
+				{ headers }
+			);
+
+			if (res.status !== 200)
+				throw new Error("Space metadata could not be loaded.");
+			const _host = (await res.json()).host;
+
+			return {
+				space_id: app_reference,
+				...determine_protocol(_host)
+			};
+		} catch (e) {
+			throw new Error("Space metadata could not be loaded." + e.message);
+		}
+	}
+
+	if (RE_SPACE_DOMAIN.test(_app_reference)) {
+		const { ws_protocol, http_protocol, host } =
+			determine_protocol(_app_reference);
+
+		return {
+			space_id: host.replace(".hf.space", ""),
+			ws_protocol,
+			http_protocol,
+			host
+		};
+	}
+
+	return {
+		space_id: false,
+		...determine_protocol(_app_reference)
+	};
+}
+
+export function map_names_to_ids(
+	fns: Config["dependencies"]
+): Record<string, number> {
+	let apis: Record<string, number> = {};
+
+	fns.forEach(({ api_name }, i) => {
+		if (api_name) apis[api_name] = i;
+	});
+
+	return apis;
+}
+
+const RE_DISABLED_DISCUSSION =
+	/^(?=[^]*\b[dD]iscussions{0,1}\b)(?=[^]*\b[dD]isabled\b)[^]*$/;
+export async function discussions_enabled(space_id: string): Promise<boolean> {
+	try {
+		const r = await fetch(
+			`https://huggingface.co/api/spaces/${space_id}/discussions`,
+			{
+				method: "HEAD"
+			}
+		);
+		const error = r.headers.get("x-error-message");
+
+		if (error && RE_DISABLED_DISCUSSION.test(error)) return false;
+		return true;
+	} catch (e) {
+		return false;
+	}
+}
+
+export async function get_space_hardware(
+	space_id: string,
+	token: `hf_${string}`
+): Promise<(typeof hardware_types)[number]> {
+	const headers: { Authorization?: string } = {};
+	if (token) {
+		headers.Authorization = `Bearer ${token}`;
+	}
+
+	try {
+		const res = await fetch(
+			`https://huggingface.co/api/spaces/${space_id}/runtime`,
+			{ headers }
+		);
+
+		if (res.status !== 200)
+			throw new Error("Space hardware could not be obtained.");
+
+		const { hardware } = await res.json();
+
+		return hardware;
+	} catch (e) {
+		throw new Error(e.message);
+	}
+}
+
+export async function set_space_hardware(
+	space_id: string,
+	new_hardware: (typeof hardware_types)[number],
+	token: `hf_${string}`
+): Promise<(typeof hardware_types)[number]> {
+	const headers: { Authorization?: string } = {};
+	if (token) {
+		headers.Authorization = `Bearer ${token}`;
+	}
+
+	try {
+		const res = await fetch(
+			`https://huggingface.co/api/spaces/${space_id}/hardware`,
+			{ headers, body: JSON.stringify(new_hardware) }
+		);
+
+		if (res.status !== 200)
+			throw new Error(
+				"Space hardware could not be set. Please ensure the space hardware provided is valid and that a Hugging Face token is passed in."
+			);
+
+		const { hardware } = await res.json();
+
+		return hardware;
+	} catch (e) {
+		throw new Error(e.message);
+	}
+}
+
+export async function set_space_timeout(
+	space_id: string,
+	timeout: number,
+	token: `hf_${string}`
+): Promise<number> {
+	const headers: { Authorization?: string } = {};
+	if (token) {
+		headers.Authorization = `Bearer ${token}`;
+	}
+
+	try {
+		const res = await fetch(
+			`https://huggingface.co/api/spaces/${space_id}/hardware`,
+			{ headers, body: JSON.stringify({ seconds: timeout }) }
+		);
+
+		if (res.status !== 200)
+			throw new Error(
+				"Space hardware could not be set. Please ensure the space hardware provided is valid and that a Hugging Face token is passed in."
+			);
+
+		const { hardware } = await res.json();
+
+		return hardware;
+	} catch (e) {
+		throw new Error(e.message);
+	}
+}
+
+export const hardware_types = [
+	"cpu-basic",
+	"cpu-upgrade",
+	"t4-small",
+	"t4-medium",
+	"a10g-small",
+	"a10g-large",
+	"a100-large"
+] as const;

testbed/gradio-app__gradio/client/js/tsconfig.json

@@ -0,0 +1,14 @@
+{
+	"include": ["src/**/*"],
+	"exclude": ["src/**/*.test.ts", "src/**/*.node-test.ts"],
+	"compilerOptions": {
+		"allowJs": true,
+		"declaration": true,
+		"emitDeclarationOnly": true,
+		"outDir": "dist",
+		"declarationMap": true,
+		"module": "es2020",
+		"moduleResolution": "node16",
+		"skipDefaultLibCheck": true
+	}
+}

testbed/gradio-app__gradio/client/js/vite.config.js

@@ -0,0 +1,23 @@
+import { defineConfig } from "vite";
+
+export default defineConfig({
+	build: {
+		// minify: true,
+		lib: {
+			entry: "src/index.ts",
+			formats: ["es"]
+		},
+		rollupOptions: {
+			input: "src/index.ts",
+			output: {
+				dir: "dist"
+			}
+		}
+	},
+
+	ssr: {
+		target: "node",
+		format: "esm",
+		noExternal: ["ws", "semiver"]
+	}
+});

testbed/gradio-app__gradio/client/python/CHANGELOG.md

@@ -0,0 +1,402 @@
+# gradio_client
+
+## 0.5.2
+
+### Features
+
+- [#5653](https://github.com/gradio-app/gradio/pull/5653) [`ea0e00b20`](https://github.com/gradio-app/gradio/commit/ea0e00b207b4b90a10e9d054c4202d4e705a29ba) - Prevent Clients from accessing API endpoints that set `api_name=False`.  Thanks [@abidlabs](https://github.com/abidlabs)!
+
+## 0.5.1
+
+### Features
+
+- [#5514](https://github.com/gradio-app/gradio/pull/5514) [`52f783175`](https://github.com/gradio-app/gradio/commit/52f7831751b432411e109bd41add4ab286023a8e) - refactor: Use package.json for version management.  Thanks [@DarhkVoyd](https://github.com/DarhkVoyd)!
+
+## 0.5.0
+
+### Highlights
+
+#### Enable streaming audio in python client ([#5248](https://github.com/gradio-app/gradio/pull/5248) [`390624d8`](https://github.com/gradio-app/gradio/commit/390624d8ad2b1308a5bf8384435fd0db98d8e29e))
+
+The `gradio_client` now supports streaming file outputs 🌊
+
+No new syntax! Connect to a gradio demo that supports streaming file outputs and call `predict` or `submit` as you normally would.
+
+```python
+import gradio_client as grc
+client = grc.Client("gradio/stream_audio_out")
+
+# Get the entire generated audio as a local file
+client.predict("/Users/freddy/Pictures/bark_demo.mp4", api_name="/predict")
+
+job = client.submit("/Users/freddy/Pictures/bark_demo.mp4", api_name="/predict")
+
+# Get the entire generated audio as a local file
+job.result()
+
+# Each individual chunk
+job.outputs()
+```
+
+ Thanks [@freddyaboulton](https://github.com/freddyaboulton)!
+
+### Fixes
+
+- [#5295](https://github.com/gradio-app/gradio/pull/5295) [`7b8fa8aa`](https://github.com/gradio-app/gradio/commit/7b8fa8aa58f95f5046b9add64b40368bd3f1b700) - Allow caching examples with streamed output.  Thanks [@aliabid94](https://github.com/aliabid94)!
+
+## 0.4.0
+
+### Highlights
+
+#### Client.predict will now return the final output for streaming endpoints ([#5057](https://github.com/gradio-app/gradio/pull/5057) [`35856f8b`](https://github.com/gradio-app/gradio/commit/35856f8b54548cae7bd3b8d6a4de69e1748283b2))
+
+### This is a breaking change (for gradio_client only)!
+
+Previously, `Client.predict` would only return the first output of an endpoint that streamed results. This was causing confusion for developers that wanted to call these streaming demos via the client.
+
+We realize that developers using the client don't know the internals of whether a demo streams or not, so we're changing the behavior of predict to match developer expectations.
+
+Using `Client.predict` will now return the final output of a streaming endpoint. This will make it even easier to use gradio apps via the client.
+
+ Thanks [@freddyaboulton](https://github.com/freddyaboulton)!
+
+### Features
+
+- [#5076](https://github.com/gradio-app/gradio/pull/5076) [`2745075a`](https://github.com/gradio-app/gradio/commit/2745075a26f80e0e16863d483401ff1b6c5ada7a) - Add deploy_discord to docs. Thanks [@freddyaboulton](https://github.com/freddyaboulton)!
+
+### Fixes
+
+- [#5061](https://github.com/gradio-app/gradio/pull/5061) [`136adc9c`](https://github.com/gradio-app/gradio/commit/136adc9ccb23e5cb4d02d2e88f23f0b850041f98) - Ensure `gradio_client` is backwards compatible with `gradio==3.24.1`. Thanks [@abidlabs](https://github.com/abidlabs)!
+
+## 0.3.0
+
+### Highlights
+
+#### Create Discord Bots from Gradio Apps 🤖 ([#4960](https://github.com/gradio-app/gradio/pull/4960) [`46e4ef67`](https://github.com/gradio-app/gradio/commit/46e4ef67d287dd68a91473b73172b29cbad064bc))
+
+We're excited to announce that Gradio can now automatically create a discord bot from any `gr.ChatInterface` app.
+
+It's as easy as importing `gradio_client`, connecting to the app, and calling `deploy_discord`!
+
+_🦙 Turning Llama 2 70b into a discord bot 🦙_
+
+```python
+import gradio_client as grc
+grc.Client("ysharma/Explore_llamav2_with_TGI").deploy_discord(to_id="llama2-70b-discord-bot")
+```
+
+<img src="https://gradio-builds.s3.amazonaws.com/demo-files/discordbots/guide/llama_chat.gif">
+
+#### Getting started with template spaces
+
+To help get you started, we have created an organization on Hugging Face called [gradio-discord-bots](https://huggingface.co/gradio-discord-bots) with template spaces you can use to turn state of the art LLMs powered by Gradio to discord bots.
+
+Currently we have template spaces for:
+
+- [Llama-2-70b-chat-hf](https://huggingface.co/spaces/gradio-discord-bots/Llama-2-70b-chat-hf) powered by a FREE Hugging Face Inference Endpoint!
+- [Llama-2-13b-chat-hf](https://huggingface.co/spaces/gradio-discord-bots/Llama-2-13b-chat-hf) powered by Hugging Face Inference Endpoints.
+- [Llama-2-13b-chat-hf](https://huggingface.co/spaces/gradio-discord-bots/llama-2-13b-chat-transformers) powered by Hugging Face transformers.
+- [falcon-7b-instruct](https://huggingface.co/spaces/gradio-discord-bots/falcon-7b-instruct) powered by Hugging Face Inference Endpoints.
+- [gpt-3.5-turbo](https://huggingface.co/spaces/gradio-discord-bots/gpt-35-turbo), powered by openai. Requires an OpenAI key.
+
+But once again, you can deploy ANY `gr.ChatInterface` app exposed on the internet! So don't hesitate to try it on your own Chatbots.
+
+❗️ Additional Note ❗️: Technically, any gradio app that exposes an api route that takes in a single string and outputs a single string can be deployed to discord. But `gr.ChatInterface` apps naturally lend themselves to discord's chat functionality so we suggest you start with those.
+
+Thanks [@freddyaboulton](https://github.com/freddyaboulton)!
+
+### New Features:
+
+- Endpoints that return layout components are now properly handled in the `submit` and `view_api` methods. Output layout components are not returned by the API but all other components are (excluding `gr.State`). By [@freddyaboulton](https://github.com/freddyaboulton) in [PR 4871](https://github.com/gradio-app/gradio/pull/4871)
+
+### Bug Fixes:
+
+No changes to highlight
+
+### Breaking Changes:
+
+No changes to highlight.
+
+### Full Changelog:
+
+No changes to highlight.
+
+# 0.2.9
+
+### New Features:
+
+No changes to highlight
+
+### Bug Fixes:
+
+- Fix bug determining the api name when a demo has `api_name=False` by [@freddyboulton](https://github.com/freddyaboulton) in [PR 4886](https://github.com/gradio-app/gradio/pull/4886)
+
+### Breaking Changes:
+
+No changes to highlight.
+
+### Full Changelog:
+
+- Pinned dependencies to major versions to reduce the likelihood of a broken `gradio_client` due to changes in downstream dependencies by [@abidlabs](https://github.com/abidlabs) in [PR 4885](https://github.com/gradio-app/gradio/pull/4885)
+
+# 0.2.8
+
+### New Features:
+
+- Support loading gradio apps where `api_name=False` by [@abidlabs](https://github.com/abidlabs) in [PR 4683](https://github.com/gradio-app/gradio/pull/4683)
+
+### Bug Fixes:
+
+- Fix bug where space duplication would error if the demo has cpu-basic hardware by [@freddyaboulton](https://github.com/freddyaboulton) in [PR 4583](https://github.com/gradio-app/gradio/pull/4583)
+- Fixes and optimizations to URL/download functions by [@akx](https://github.com/akx) in [PR 4695](https://github.com/gradio-app/gradio/pull/4695)
+
+### Breaking Changes:
+
+No changes to highlight.
+
+### Full Changelog:
+
+No changes to highlight.
+
+# 0.2.7
+
+### New Features:
+
+- The output directory for files downloaded via the Client can now be set by the `output_dir` parameter in `Client` by [@abidlabs](https://github.com/abidlabs) in [PR 4501](https://github.com/gradio-app/gradio/pull/4501)
+
+### Bug Fixes:
+
+- The output directory for files downloaded via the Client are now set to a temporary directory by default (instead of the working directory in some cases) by [@abidlabs](https://github.com/abidlabs) in [PR 4501](https://github.com/gradio-app/gradio/pull/4501)
+
+### Breaking Changes:
+
+No changes to highlight.
+
+### Full Changelog:
+
+No changes to highlight.
+
+# 0.2.6
+
+### New Features:
+
+No changes to highlight.
+
+### Bug Fixes:
+
+- Fixed bug file deserialization didn't preserve all file extensions by [@freddyaboulton](https://github.com/freddyaboulton) in [PR 4440](https://github.com/gradio-app/gradio/pull/4440)
+- Fixed bug where mounted apps could not be called via the client by [@freddyaboulton](https://github.com/freddyaboulton) in [PR 4435](https://github.com/gradio-app/gradio/pull/4435)
+
+### Breaking Changes:
+
+No changes to highlight.
+
+### Full Changelog:
+
+No changes to highlight.
+
+# 0.2.5
+
+### New Features:
+
+No changes to highlight.
+
+### Bug Fixes:
+
+- Fixes parameter names not showing underscores by [@abidlabs](https://github.com/abidlabs) in [PR 4230](https://github.com/gradio-app/gradio/pull/4230)
+- Fixes issue in which state was not handled correctly if `serialize=False` by [@abidlabs](https://github.com/abidlabs) in [PR 4230](https://github.com/gradio-app/gradio/pull/4230)
+
+### Breaking Changes:
+
+No changes to highlight.
+
+### Full Changelog:
+
+No changes to highlight.
+
+# 0.2.4
+
+### Bug Fixes:
+
+- Fixes missing serialization classes for several components: `Barplot`, `Lineplot`, `Scatterplot`, `AnnotatedImage`, `Interpretation` by [@abidlabs](https://github.com/abidlabs) in [PR 4167](https://github.com/gradio-app/gradio/pull/4167)
+
+### Documentation Changes:
+
+No changes to highlight.
+
+### Testing and Infrastructure Changes:
+
+No changes to highlight.
+
+### Breaking Changes:
+
+No changes to highlight.
+
+### Full Changelog:
+
+No changes to highlight.
+
+### Contributors Shoutout:
+
+No changes to highlight.
+
+# 0.2.3
+
+### New Features:
+
+No changes to highlight.
+
+### Bug Fixes:
+
+- Fix example inputs for `gr.File(file_count='multiple')` output components by [@freddyaboulton](https://github.com/freddyaboulton) in [PR 4153](https://github.com/gradio-app/gradio/pull/4153)
+
+### Documentation Changes:
+
+No changes to highlight.
+
+### Testing and Infrastructure Changes:
+
+No changes to highlight.
+
+### Breaking Changes:
+
+No changes to highlight.
+
+### Full Changelog:
+
+No changes to highlight.
+
+### Contributors Shoutout:
+
+No changes to highlight.
+
+# 0.2.2
+
+### New Features:
+
+No changes to highlight.
+
+### Bug Fixes:
+
+- Only send request to `/info` route if demo version is above `3.28.3` by [@freddyaboulton](https://github.com/freddyaboulton) in [PR 4109](https://github.com/gradio-app/gradio/pull/4109)
+
+### Other Changes:
+
+- Fix bug in test from gradio 3.29.0 refactor by [@freddyaboulton](https://github.com/freddyaboulton) in [PR 4138](https://github.com/gradio-app/gradio/pull/4138)
+
+### Breaking Changes:
+
+No changes to highlight.
+
+# 0.2.1
+
+### New Features:
+
+No changes to highlight.
+
+### Bug Fixes:
+
+Removes extraneous `State` component info from the `Client.view_api()` method by [@abidlabs](https://github.com/freddyaboulton) in [PR 4107](https://github.com/gradio-app/gradio/pull/4107)
+
+### Documentation Changes:
+
+No changes to highlight.
+
+### Testing and Infrastructure Changes:
+
+Separates flaky tests from non-flaky tests by [@abidlabs](https://github.com/freddyaboulton) in [PR 4107](https://github.com/gradio-app/gradio/pull/4107)
+
+### Breaking Changes:
+
+No changes to highlight.
+
+### Full Changelog:
+
+No changes to highlight.
+
+### Contributors Shoutout:
+
+No changes to highlight.
+
+# 0.1.4
+
+### New Features:
+
+- Progress Updates from `gr.Progress()` can be accessed via `job.status().progress_data` by @freddyaboulton](https://github.com/freddyaboulton) in [PR 3924](https://github.com/gradio-app/gradio/pull/3924)
+
+### Bug Fixes:
+
+- Fixed bug where unnamed routes where displayed with `api_name` instead of `fn_index` in `view_api` by [@freddyaboulton](https://github.com/freddyaboulton) in [PR 3972](https://github.com/gradio-app/gradio/pull/3972)
+
+### Documentation Changes:
+
+No changes to highlight.
+
+### Testing and Infrastructure Changes:
+
+No changes to highlight.
+
+### Breaking Changes:
+
+No changes to highlight.
+
+### Full Changelog:
+
+No changes to highlight.
+
+### Contributors Shoutout:
+
+No changes to highlight.
+
+# 0.1.3
+
+### New Features:
+
+No changes to highlight.
+
+### Bug Fixes:
+
+- Fixed bug where `Video` components in latest gradio were not able to be deserialized by [@freddyaboulton](https://github.com/freddyaboulton) in [PR 3860](https://github.com/gradio-app/gradio/pull/3860)
+
+### Documentation Changes:
+
+No changes to highlight.
+
+### Testing and Infrastructure Changes:
+
+No changes to highlight.
+
+### Breaking Changes:
+
+No changes to highlight.
+
+### Full Changelog:
+
+No changes to highlight.
+
+### Contributors Shoutout:
+
+No changes to highlight.
+
+# 0.1.2
+
+First public release of the Gradio Client library! The `gradio_client` Python library that makes it very easy to use any Gradio app as an API.
+
+As an example, consider this [Hugging Face Space that transcribes audio files](https://huggingface.co/spaces/abidlabs/whisper) that are recorded from the microphone.
+
+![](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/gradio-guides/whisper-screenshot.jpg)
+
+Using the `gradio_client` library, we can easily use the Gradio as an API to transcribe audio files programmatically.
+
+Here's the entire code to do it:
+
+```python
+from gradio_client import Client
+
+client = Client("abidlabs/whisper")
+client.predict("audio_sample.wav")
+
+>> "This is a test of the whisper speech recognition model."
+```
+
+Read more about how to use the `gradio_client` library here: https://gradio.app/getting-started-with-the-python-client/

testbed/gradio-app__gradio/client/python/README.md

@@ -0,0 +1,143 @@
+# `gradio_client`: Use a Gradio app as an API -- in 3 lines of Python
+
+This directory contains the source code for `gradio_client`, a lightweight Python library that makes it very easy to use any Gradio app as an API.
+
+As an example, consider this [Hugging Face Space that transcribes audio files](https://huggingface.co/spaces/abidlabs/whisper) that are recorded from the microphone.
+
+![](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/gradio-guides/whisper-screenshot.jpg)
+
+Using the `gradio_client` library, we can easily use the Gradio as an API to transcribe audio files programmatically.
+
+Here's the entire code to do it:
+
+```python
+from gradio_client import Client
+
+client = Client("abidlabs/whisper")
+client.predict("audio_sample.wav")
+
+>> "This is a test of the whisper speech recognition model."
+```
+
+The Gradio client works with any Gradio Space, whether it be an image generator, a stateful chatbot, or a tax calculator.
+
+## Installation
+
+If you already have a recent version of `gradio`, then the `gradio_client` is included as a dependency.
+
+Otherwise, the lightweight `gradio_client` package can be installed from pip (or pip3) and works with Python versions 3.8 or higher:
+
+```bash
+$ pip install gradio_client
+```
+
+## Basic Usage
+
+### Connecting to a Space or a Gradio app
+
+Start by connecting instantiating a `Client` object and connecting it to a Gradio app that is running on Spaces (or anywhere else)!
+
+**Connecting to a Space**
+
+```python
+from gradio_client import Client
+
+client = Client("abidlabs/en2fr")  # a Space that translates from English to French
+```
+
+You can also connect to private Spaces by passing in your HF token with the `hf_token` parameter. You can get your HF token here: https://huggingface.co/settings/tokens
+
+```python
+from gradio_client import Client
+
+client = Client("abidlabs/my-private-space", hf_token="...")
+```
+
+**Duplicating a Space for private use**
+
+While you can use any public Space as an API, you may get rate limited by Hugging Face if you make too many requests. For unlimited usage of a Space, simply duplicate the Space to create a private Space,
+and then use it to make as many requests as you'd like!
+
+The `gradio_client` includes a class method: `Client.duplicate()` to make this process simple:
+
+```python
+from gradio_client import Client
+
+client = Client.duplicate("abidlabs/whisper")
+client.predict("audio_sample.wav")
+
+>> "This is a test of the whisper speech recognition model."
+```
+
+If you have previously duplicated a Space, re-running `duplicate()` will _not_ create a new Space. Instead, the Client will attach to the previously-created Space. So it is safe to re-run the `Client.duplicate()` method multiple times.
+
+**Note:** if the original Space uses GPUs, your private Space will as well, and your Hugging Face account will get billed based on the price of the GPU. To minimize charges, your Space will automatically go to sleep after 1 hour of inactivity. You can also set the hardware using the `hardware` parameter of `duplicate()`.
+
+**Connecting a general Gradio app**
+
+If your app is running somewhere else, just provide the full URL instead, including the "http://" or "https://". Here's an example of making predictions to a Gradio app that is running on a share URL:
+
+```python
+from gradio_client import Client
+
+client = Client("https://bec81a83-5b5c-471e.gradio.live")
+```
+
+### Inspecting the API endpoints
+
+Once you have connected to a Gradio app, you can view the APIs that are available to you by calling the `.view_api()` method. For the Whisper Space, we see the following:
+
+```
+Client.predict() Usage Info
+---------------------------
+Named API endpoints: 1
+
+ - predict(input_audio, api_name="/predict") -> value_0
+    Parameters:
+     - [Audio] input_audio: str (filepath or URL)
+    Returns:
+     - [Textbox] value_0: str (value)
+```
+
+This shows us that we have 1 API endpoint in this space, and shows us how to use the API endpoint to make a prediction: we should call the `.predict()` method, providing a parameter `input_audio` of type `str`, which is a `filepath or URL`.
+
+We should also provide the `api_name='/predict'` argument. Although this isn't necessary if a Gradio app has a single named endpoint, it does allow us to call different endpoints in a single app if they are available. If an app has unnamed API endpoints, these can also be displayed by running `.view_api(all_endpoints=True)`.
+
+### Making a prediction
+
+The simplest way to make a prediction is simply to call the `.predict()` function with the appropriate arguments:
+
+```python
+from gradio_client import Client
+
+client = Client("abidlabs/en2fr")
+client.predict("Hello")
+
+>> Bonjour
+```
+
+If there are multiple parameters, then you should pass them as separate arguments to `.predict()`, like this:
+
+```python
+from gradio_client import Client
+
+client = Client("gradio/calculator")
+client.predict(4, "add", 5)
+
+>> 9.0
+```
+
+For certain inputs, such as images, you should pass in the filepath or URL to the file. Likewise, for the corresponding output types, you will get a filepath or URL returned.
+
+```python
+from gradio_client import Client
+
+client = Client("abidlabs/whisper")
+client.predict("https://audio-samples.github.io/samples/mp3/blizzard_unconditional/sample-0.mp3")
+
+>> "My thought I have nobody by a beauty and will as you poured. Mr. Rochester is serve in that so don't find simpus, and devoted abode, to at might in a r—"
+```
+
+## Advanced Usage
+
+For more ways to use the Gradio Python Client, check out our dedicated Guide on the Python client, available here: https://www.gradio.app/getting-started-with-the-python-client/

testbed/gradio-app__gradio/client/python/build_pypi.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+set -e
+
+cd "$(dirname ${0})"
+
+python3 -m pip install build
+rm -rf dist/*
+rm -rf build/*
+python3 -m build

testbed/gradio-app__gradio/client/python/gradio_client/CHANGELOG.md

@@ -0,0 +1,402 @@
+# gradio_client
+
+## 0.5.2
+
+### Features
+
+- [#5653](https://github.com/gradio-app/gradio/pull/5653) [`ea0e00b20`](https://github.com/gradio-app/gradio/commit/ea0e00b207b4b90a10e9d054c4202d4e705a29ba) - Prevent Clients from accessing API endpoints that set `api_name=False`.  Thanks [@abidlabs](https://github.com/abidlabs)!
+
+## 0.5.1
+
+### Features
+
+- [#5514](https://github.com/gradio-app/gradio/pull/5514) [`52f783175`](https://github.com/gradio-app/gradio/commit/52f7831751b432411e109bd41add4ab286023a8e) - refactor: Use package.json for version management.  Thanks [@DarhkVoyd](https://github.com/DarhkVoyd)!
+
+## 0.5.0
+
+### Highlights
+
+#### Enable streaming audio in python client ([#5248](https://github.com/gradio-app/gradio/pull/5248) [`390624d8`](https://github.com/gradio-app/gradio/commit/390624d8ad2b1308a5bf8384435fd0db98d8e29e))
+
+The `gradio_client` now supports streaming file outputs 🌊
+
+No new syntax! Connect to a gradio demo that supports streaming file outputs and call `predict` or `submit` as you normally would.
+
+```python
+import gradio_client as grc
+client = grc.Client("gradio/stream_audio_out")
+
+# Get the entire generated audio as a local file
+client.predict("/Users/freddy/Pictures/bark_demo.mp4", api_name="/predict")
+
+job = client.submit("/Users/freddy/Pictures/bark_demo.mp4", api_name="/predict")
+
+# Get the entire generated audio as a local file
+job.result()
+
+# Each individual chunk
+job.outputs()
+```
+
+ Thanks [@freddyaboulton](https://github.com/freddyaboulton)!
+
+### Fixes
+
+- [#5295](https://github.com/gradio-app/gradio/pull/5295) [`7b8fa8aa`](https://github.com/gradio-app/gradio/commit/7b8fa8aa58f95f5046b9add64b40368bd3f1b700) - Allow caching examples with streamed output.  Thanks [@aliabid94](https://github.com/aliabid94)!
+
+## 0.4.0
+
+### Highlights
+
+#### Client.predict will now return the final output for streaming endpoints ([#5057](https://github.com/gradio-app/gradio/pull/5057) [`35856f8b`](https://github.com/gradio-app/gradio/commit/35856f8b54548cae7bd3b8d6a4de69e1748283b2))
+
+### This is a breaking change (for gradio_client only)!
+
+Previously, `Client.predict` would only return the first output of an endpoint that streamed results. This was causing confusion for developers that wanted to call these streaming demos via the client.
+
+We realize that developers using the client don't know the internals of whether a demo streams or not, so we're changing the behavior of predict to match developer expectations.
+
+Using `Client.predict` will now return the final output of a streaming endpoint. This will make it even easier to use gradio apps via the client.
+
+ Thanks [@freddyaboulton](https://github.com/freddyaboulton)!
+
+### Features
+
+- [#5076](https://github.com/gradio-app/gradio/pull/5076) [`2745075a`](https://github.com/gradio-app/gradio/commit/2745075a26f80e0e16863d483401ff1b6c5ada7a) - Add deploy_discord to docs. Thanks [@freddyaboulton](https://github.com/freddyaboulton)!
+
+### Fixes
+
+- [#5061](https://github.com/gradio-app/gradio/pull/5061) [`136adc9c`](https://github.com/gradio-app/gradio/commit/136adc9ccb23e5cb4d02d2e88f23f0b850041f98) - Ensure `gradio_client` is backwards compatible with `gradio==3.24.1`. Thanks [@abidlabs](https://github.com/abidlabs)!
+
+## 0.3.0
+
+### Highlights
+
+#### Create Discord Bots from Gradio Apps 🤖 ([#4960](https://github.com/gradio-app/gradio/pull/4960) [`46e4ef67`](https://github.com/gradio-app/gradio/commit/46e4ef67d287dd68a91473b73172b29cbad064bc))
+
+We're excited to announce that Gradio can now automatically create a discord bot from any `gr.ChatInterface` app.
+
+It's as easy as importing `gradio_client`, connecting to the app, and calling `deploy_discord`!
+
+_🦙 Turning Llama 2 70b into a discord bot 🦙_
+
+```python
+import gradio_client as grc
+grc.Client("ysharma/Explore_llamav2_with_TGI").deploy_discord(to_id="llama2-70b-discord-bot")
+```
+
+<img src="https://gradio-builds.s3.amazonaws.com/demo-files/discordbots/guide/llama_chat.gif">
+
+#### Getting started with template spaces
+
+To help get you started, we have created an organization on Hugging Face called [gradio-discord-bots](https://huggingface.co/gradio-discord-bots) with template spaces you can use to turn state of the art LLMs powered by Gradio to discord bots.
+
+Currently we have template spaces for:
+
+- [Llama-2-70b-chat-hf](https://huggingface.co/spaces/gradio-discord-bots/Llama-2-70b-chat-hf) powered by a FREE Hugging Face Inference Endpoint!
+- [Llama-2-13b-chat-hf](https://huggingface.co/spaces/gradio-discord-bots/Llama-2-13b-chat-hf) powered by Hugging Face Inference Endpoints.
+- [Llama-2-13b-chat-hf](https://huggingface.co/spaces/gradio-discord-bots/llama-2-13b-chat-transformers) powered by Hugging Face transformers.
+- [falcon-7b-instruct](https://huggingface.co/spaces/gradio-discord-bots/falcon-7b-instruct) powered by Hugging Face Inference Endpoints.
+- [gpt-3.5-turbo](https://huggingface.co/spaces/gradio-discord-bots/gpt-35-turbo), powered by openai. Requires an OpenAI key.
+
+But once again, you can deploy ANY `gr.ChatInterface` app exposed on the internet! So don't hesitate to try it on your own Chatbots.
+
+❗️ Additional Note ❗️: Technically, any gradio app that exposes an api route that takes in a single string and outputs a single string can be deployed to discord. But `gr.ChatInterface` apps naturally lend themselves to discord's chat functionality so we suggest you start with those.
+
+Thanks [@freddyaboulton](https://github.com/freddyaboulton)!
+
+### New Features:
+
+- Endpoints that return layout components are now properly handled in the `submit` and `view_api` methods. Output layout components are not returned by the API but all other components are (excluding `gr.State`). By [@freddyaboulton](https://github.com/freddyaboulton) in [PR 4871](https://github.com/gradio-app/gradio/pull/4871)
+
+### Bug Fixes:
+
+No changes to highlight
+
+### Breaking Changes:
+
+No changes to highlight.
+
+### Full Changelog:
+
+No changes to highlight.
+
+# 0.2.9
+
+### New Features:
+
+No changes to highlight
+
+### Bug Fixes:
+
+- Fix bug determining the api name when a demo has `api_name=False` by [@freddyboulton](https://github.com/freddyaboulton) in [PR 4886](https://github.com/gradio-app/gradio/pull/4886)
+
+### Breaking Changes:
+
+No changes to highlight.
+
+### Full Changelog:
+
+- Pinned dependencies to major versions to reduce the likelihood of a broken `gradio_client` due to changes in downstream dependencies by [@abidlabs](https://github.com/abidlabs) in [PR 4885](https://github.com/gradio-app/gradio/pull/4885)
+
+# 0.2.8
+
+### New Features:
+
+- Support loading gradio apps where `api_name=False` by [@abidlabs](https://github.com/abidlabs) in [PR 4683](https://github.com/gradio-app/gradio/pull/4683)
+
+### Bug Fixes:
+
+- Fix bug where space duplication would error if the demo has cpu-basic hardware by [@freddyaboulton](https://github.com/freddyaboulton) in [PR 4583](https://github.com/gradio-app/gradio/pull/4583)
+- Fixes and optimizations to URL/download functions by [@akx](https://github.com/akx) in [PR 4695](https://github.com/gradio-app/gradio/pull/4695)
+
+### Breaking Changes:
+
+No changes to highlight.
+
+### Full Changelog:
+
+No changes to highlight.
+
+# 0.2.7
+
+### New Features:
+
+- The output directory for files downloaded via the Client can now be set by the `output_dir` parameter in `Client` by [@abidlabs](https://github.com/abidlabs) in [PR 4501](https://github.com/gradio-app/gradio/pull/4501)
+
+### Bug Fixes:
+
+- The output directory for files downloaded via the Client are now set to a temporary directory by default (instead of the working directory in some cases) by [@abidlabs](https://github.com/abidlabs) in [PR 4501](https://github.com/gradio-app/gradio/pull/4501)
+
+### Breaking Changes:
+
+No changes to highlight.
+
+### Full Changelog:
+
+No changes to highlight.
+
+# 0.2.6
+
+### New Features:
+
+No changes to highlight.
+
+### Bug Fixes:
+
+- Fixed bug file deserialization didn't preserve all file extensions by [@freddyaboulton](https://github.com/freddyaboulton) in [PR 4440](https://github.com/gradio-app/gradio/pull/4440)
+- Fixed bug where mounted apps could not be called via the client by [@freddyaboulton](https://github.com/freddyaboulton) in [PR 4435](https://github.com/gradio-app/gradio/pull/4435)
+
+### Breaking Changes:
+
+No changes to highlight.
+
+### Full Changelog:
+
+No changes to highlight.
+
+# 0.2.5
+
+### New Features:
+
+No changes to highlight.
+
+### Bug Fixes:
+
+- Fixes parameter names not showing underscores by [@abidlabs](https://github.com/abidlabs) in [PR 4230](https://github.com/gradio-app/gradio/pull/4230)
+- Fixes issue in which state was not handled correctly if `serialize=False` by [@abidlabs](https://github.com/abidlabs) in [PR 4230](https://github.com/gradio-app/gradio/pull/4230)
+
+### Breaking Changes:
+
+No changes to highlight.
+
+### Full Changelog:
+
+No changes to highlight.
+
+# 0.2.4
+
+### Bug Fixes:
+
+- Fixes missing serialization classes for several components: `Barplot`, `Lineplot`, `Scatterplot`, `AnnotatedImage`, `Interpretation` by [@abidlabs](https://github.com/abidlabs) in [PR 4167](https://github.com/gradio-app/gradio/pull/4167)
+
+### Documentation Changes:
+
+No changes to highlight.
+
+### Testing and Infrastructure Changes:
+
+No changes to highlight.
+
+### Breaking Changes:
+
+No changes to highlight.
+
+### Full Changelog:
+
+No changes to highlight.
+
+### Contributors Shoutout:
+
+No changes to highlight.
+
+# 0.2.3
+
+### New Features:
+
+No changes to highlight.
+
+### Bug Fixes:
+
+- Fix example inputs for `gr.File(file_count='multiple')` output components by [@freddyaboulton](https://github.com/freddyaboulton) in [PR 4153](https://github.com/gradio-app/gradio/pull/4153)
+
+### Documentation Changes:
+
+No changes to highlight.
+
+### Testing and Infrastructure Changes:
+
+No changes to highlight.
+
+### Breaking Changes:
+
+No changes to highlight.
+
+### Full Changelog:
+
+No changes to highlight.
+
+### Contributors Shoutout:
+
+No changes to highlight.
+
+# 0.2.2
+
+### New Features:
+
+No changes to highlight.
+
+### Bug Fixes:
+
+- Only send request to `/info` route if demo version is above `3.28.3` by [@freddyaboulton](https://github.com/freddyaboulton) in [PR 4109](https://github.com/gradio-app/gradio/pull/4109)
+
+### Other Changes:
+
+- Fix bug in test from gradio 3.29.0 refactor by [@freddyaboulton](https://github.com/freddyaboulton) in [PR 4138](https://github.com/gradio-app/gradio/pull/4138)
+
+### Breaking Changes:
+
+No changes to highlight.
+
+# 0.2.1
+
+### New Features:
+
+No changes to highlight.
+
+### Bug Fixes:
+
+Removes extraneous `State` component info from the `Client.view_api()` method by [@abidlabs](https://github.com/freddyaboulton) in [PR 4107](https://github.com/gradio-app/gradio/pull/4107)
+
+### Documentation Changes:
+
+No changes to highlight.
+
+### Testing and Infrastructure Changes:
+
+Separates flaky tests from non-flaky tests by [@abidlabs](https://github.com/freddyaboulton) in [PR 4107](https://github.com/gradio-app/gradio/pull/4107)
+
+### Breaking Changes:
+
+No changes to highlight.
+
+### Full Changelog:
+
+No changes to highlight.
+
+### Contributors Shoutout:
+
+No changes to highlight.
+
+# 0.1.4
+
+### New Features:
+
+- Progress Updates from `gr.Progress()` can be accessed via `job.status().progress_data` by @freddyaboulton](https://github.com/freddyaboulton) in [PR 3924](https://github.com/gradio-app/gradio/pull/3924)
+
+### Bug Fixes:
+
+- Fixed bug where unnamed routes where displayed with `api_name` instead of `fn_index` in `view_api` by [@freddyaboulton](https://github.com/freddyaboulton) in [PR 3972](https://github.com/gradio-app/gradio/pull/3972)
+
+### Documentation Changes:
+
+No changes to highlight.
+
+### Testing and Infrastructure Changes:
+
+No changes to highlight.
+
+### Breaking Changes:
+
+No changes to highlight.
+
+### Full Changelog:
+
+No changes to highlight.
+
+### Contributors Shoutout:
+
+No changes to highlight.
+
+# 0.1.3
+
+### New Features:
+
+No changes to highlight.
+
+### Bug Fixes:
+
+- Fixed bug where `Video` components in latest gradio were not able to be deserialized by [@freddyaboulton](https://github.com/freddyaboulton) in [PR 3860](https://github.com/gradio-app/gradio/pull/3860)
+
+### Documentation Changes:
+
+No changes to highlight.
+
+### Testing and Infrastructure Changes:
+
+No changes to highlight.
+
+### Breaking Changes:
+
+No changes to highlight.
+
+### Full Changelog:
+
+No changes to highlight.
+
+### Contributors Shoutout:
+
+No changes to highlight.
+
+# 0.1.2
+
+First public release of the Gradio Client library! The `gradio_client` Python library that makes it very easy to use any Gradio app as an API.
+
+As an example, consider this [Hugging Face Space that transcribes audio files](https://huggingface.co/spaces/abidlabs/whisper) that are recorded from the microphone.
+
+![](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/gradio-guides/whisper-screenshot.jpg)
+
+Using the `gradio_client` library, we can easily use the Gradio as an API to transcribe audio files programmatically.
+
+Here's the entire code to do it:
+
+```python
+from gradio_client import Client
+
+client = Client("abidlabs/whisper")
+client.predict("audio_sample.wav")
+
+>> "This is a test of the whisper speech recognition model."
+```
+
+Read more about how to use the `gradio_client` library here: https://gradio.app/getting-started-with-the-python-client/

testbed/gradio-app__gradio/client/python/gradio_client/__init__.py

@@ -0,0 +1,7 @@
+from gradio_client.client import Client
+from gradio_client.utils import __version__
+
+__all__ = [
+    "Client",
+    "__version__",
+]

testbed/gradio-app__gradio/client/python/gradio_client/cli/__init__.py

@@ -0,0 +1,3 @@
+from gradio_client.cli import deploy_discord
+
+__all__ = ["deploy_discord"]

testbed/gradio-app__gradio/client/python/gradio_client/cli/deploy_discord.py

@@ -0,0 +1,58 @@
+import argparse
+
+from gradio_client import Client
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Deploy Space as Discord Bot.")
+    parser.add_argument("deploy-discord")
+    parser.add_argument(
+        "--src",
+        type=str,
+        help="The space id or url or gradio app you want to deploy as a gradio bot.",
+    )
+    parser.add_argument(
+        "--discord-bot-token",
+        type=str,
+        help="Discord bot token. Get one on the discord website.",
+    )
+    parser.add_argument(
+        "--api-names",
+        nargs="*",
+        help="Api names to turn into discord bots",
+        default=[],
+    )
+    parser.add_argument(
+        "--to-id",
+        type=str,
+        help="Name of the space used to host the discord bot",
+        default=None,
+    )
+    parser.add_argument(
+        "--hf-token",
+        type=str,
+        help=(
+            "Hugging Face token. Can be ommitted if you are logged in via huggingface_hub cli. "
+            "Must be provided if upstream space is private."
+        ),
+        default=None,
+    )
+    parser.add_argument(
+        "--private",
+        type=bool,
+        nargs="?",
+        help="Whether the discord bot space is private.",
+        const=True,
+        default=False,
+    )
+    args = parser.parse_args()
+    for i, name in enumerate(args.api_names):
+        if "," in name:
+            args.api_names[i] = tuple(name.split(","))
+    Client(args.src).deploy_discord(
+        discord_bot_token=args.discord_bot_token,
+        api_names=args.api_names,
+        to_id=args.to_id,
+        hf_token=args.hf_token,
+        private=args.private,
+    )

testbed/gradio-app__gradio/client/python/gradio_client/client.py

@@ -0,0 +1,1251 @@
+"""The main Client class for the Python client."""
+from __future__ import annotations
+
+import concurrent.futures
+import json
+import os
+import re
+import secrets
+import tempfile
+import threading
+import time
+import urllib.parse
+import uuid
+import warnings
+from concurrent.futures import Future
+from datetime import datetime
+from pathlib import Path
+from threading import Lock
+from typing import Any, Callable, Literal
+
+import huggingface_hub
+import requests
+import websockets
+from huggingface_hub import CommitOperationAdd, SpaceHardware, SpaceStage
+from huggingface_hub.utils import (
+    RepositoryNotFoundError,
+    build_hf_headers,
+    send_telemetry,
+)
+from packaging import version
+
+from gradio_client import serializing, utils
+from gradio_client.documentation import document, set_documentation_group
+from gradio_client.serializing import Serializable
+from gradio_client.utils import (
+    Communicator,
+    JobStatus,
+    Status,
+    StatusUpdate,
+)
+
+set_documentation_group("py-client")
+
+
+DEFAULT_TEMP_DIR = os.environ.get("GRADIO_TEMP_DIR") or str(
+    Path(tempfile.gettempdir()) / "gradio"
+)
+
+
+@document("predict", "submit", "view_api", "duplicate", "deploy_discord")
+class Client:
+    """
+    The main Client class for the Python client. This class is used to connect to a remote Gradio app and call its API endpoints.
+
+    Example:
+        from gradio_client import Client
+
+        client = Client("abidlabs/whisper-large-v2")  # connecting to a Hugging Face Space
+        client.predict("test.mp4", api_name="/predict")
+        >> What a nice recording! # returns the result of the remote API call
+
+        client = Client("https://bec81a83-5b5c-471e.gradio.live")  # connecting to a temporary Gradio share URL
+        job = client.submit("hello", api_name="/predict")  # runs the prediction in a background thread
+        job.result()
+        >> 49 # returns the result of the remote API call (blocking call)
+    """
+
+    def __init__(
+        self,
+        src: str,
+        hf_token: str | None = None,
+        max_workers: int = 40,
+        serialize: bool = True,
+        output_dir: str | Path | None = DEFAULT_TEMP_DIR,
+        verbose: bool = True,
+    ):
+        """
+        Parameters:
+            src: Either the name of the Hugging Face Space to load, (e.g. "abidlabs/whisper-large-v2") or the full URL (including "http" or "https") of the hosted Gradio app to load (e.g. "http://mydomain.com/app" or "https://bec81a83-5b5c-471e.gradio.live/").
+            hf_token: The Hugging Face token to use to access private Spaces. Automatically fetched if you are logged in via the Hugging Face Hub CLI. Obtain from: https://huggingface.co/settings/token
+            max_workers: The maximum number of thread workers that can be used to make requests to the remote Gradio app simultaneously.
+            serialize: Whether the client should serialize the inputs and deserialize the outputs of the remote API. If set to False, the client will pass the inputs and outputs as-is, without serializing/deserializing them. E.g. you if you set this to False, you'd submit an image in base64 format instead of a filepath, and you'd get back an image in base64 format from the remote API instead of a filepath.
+            output_dir: The directory to save files that are downloaded from the remote API. If None, reads from the GRADIO_TEMP_DIR environment variable. Defaults to a temporary directory on your machine.
+            verbose: Whether the client should print statements to the console.
+        """
+        self.verbose = verbose
+        self.hf_token = hf_token
+        self.serialize = serialize
+        self.headers = build_hf_headers(
+            token=hf_token,
+            library_name="gradio_client",
+            library_version=utils.__version__,
+        )
+        self.space_id = None
+        self.output_dir = output_dir
+
+        if src.startswith("http://") or src.startswith("https://"):
+            _src = src if src.endswith("/") else src + "/"
+        else:
+            _src = self._space_name_to_src(src)
+            if _src is None:
+                raise ValueError(
+                    f"Could not find Space: {src}. If it is a private Space, please provide an hf_token."
+                )
+            self.space_id = src
+        self.src = _src
+        state = self._get_space_state()
+        if state == SpaceStage.BUILDING:
+            if self.verbose:
+                print("Space is still building. Please wait...")
+            while self._get_space_state() == SpaceStage.BUILDING:
+                time.sleep(2)  # so we don't get rate limited by the API
+                pass
+        if state in utils.INVALID_RUNTIME:
+            raise ValueError(
+                f"The current space is in the invalid state: {state}. "
+                "Please contact the owner to fix this."
+            )
+        if self.verbose:
+            print(f"Loaded as API: {self.src} ✔")
+
+        self.api_url = urllib.parse.urljoin(self.src, utils.API_URL)
+        self.ws_url = urllib.parse.urljoin(
+            self.src.replace("http", "ws", 1), utils.WS_URL
+        )
+        self.upload_url = urllib.parse.urljoin(self.src, utils.UPLOAD_URL)
+        self.reset_url = urllib.parse.urljoin(self.src, utils.RESET_URL)
+        self.config = self._get_config()
+        self.session_hash = str(uuid.uuid4())
+
+        self.endpoints = [
+            Endpoint(self, fn_index, dependency)
+            for fn_index, dependency in enumerate(self.config["dependencies"])
+        ]
+
+        # Create a pool of threads to handle the requests
+        self.executor = concurrent.futures.ThreadPoolExecutor(max_workers=max_workers)
+
+        # Disable telemetry by setting the env variable HF_HUB_DISABLE_TELEMETRY=1
+        threading.Thread(target=self._telemetry_thread).start()
+
+    @classmethod
+    def duplicate(
+        cls,
+        from_id: str,
+        to_id: str | None = None,
+        hf_token: str | None = None,
+        private: bool = True,
+        hardware: Literal[
+            "cpu-basic",
+            "cpu-upgrade",
+            "t4-small",
+            "t4-medium",
+            "a10g-small",
+            "a10g-large",
+            "a100-large",
+        ]
+        | SpaceHardware
+        | None = None,
+        secrets: dict[str, str] | None = None,
+        sleep_timeout: int = 5,
+        max_workers: int = 40,
+        verbose: bool = True,
+    ):
+        """
+        Duplicates a Hugging Face Space under your account and returns a Client object
+        for the new Space. No duplication is created if the Space already exists in your
+        account (to override this, provide a new name for the new Space using `to_id`).
+        To use this method, you must provide an `hf_token` or be logged in via the Hugging
+        Face Hub CLI.
+
+        The new Space will be private by default and use the same hardware as the original
+        Space. This can be changed by using the `private` and `hardware` parameters. For
+        hardware upgrades (beyond the basic CPU tier), you may be required to provide
+        billing information on Hugging Face: https://huggingface.co/settings/billing
+
+        Parameters:
+            from_id: The name of the Hugging Face Space to duplicate in the format "{username}/{space_id}", e.g. "gradio/whisper".
+            to_id: The name of the new Hugging Face Space to create, e.g. "abidlabs/whisper-duplicate". If not provided, the new Space will be named "{your_HF_username}/{space_id}".
+            hf_token: The Hugging Face token to use to access private Spaces. Automatically fetched if you are logged in via the Hugging Face Hub CLI. Obtain from: https://huggingface.co/settings/token
+            private: Whether the new Space should be private (True) or public (False). Defaults to True.
+            hardware: The hardware tier to use for the new Space. Defaults to the same hardware tier as the original Space. Options include "cpu-basic", "cpu-upgrade", "t4-small", "t4-medium", "a10g-small", "a10g-large", "a100-large", subject to availability.
+            secrets: A dictionary of (secret key, secret value) to pass to the new Space. Defaults to None. Secrets are only used when the Space is duplicated for the first time, and are not updated if the duplicated Space already exists.
+            sleep_timeout: The number of minutes after which the duplicate Space will be puased if no requests are made to it (to minimize billing charges). Defaults to 5 minutes.
+            max_workers: The maximum number of thread workers that can be used to make requests to the remote Gradio app simultaneously.
+            verbose: Whether the client should print statements to the console.
+        Example:
+            import os
+            from gradio_client import Client
+            HF_TOKEN = os.environ.get("HF_TOKEN")
+            client = Client.duplicate("abidlabs/whisper", hf_token=HF_TOKEN)
+            client.predict("audio_sample.wav")
+            >> "This is a test of the whisper speech recognition model."
+        """
+        try:
+            original_info = huggingface_hub.get_space_runtime(from_id, token=hf_token)
+        except RepositoryNotFoundError as rnfe:
+            raise ValueError(
+                f"Could not find Space: {from_id}. If it is a private Space, please provide an `hf_token`."
+            ) from rnfe
+        if to_id:
+            if "/" in to_id:
+                to_id = to_id.split("/")[1]
+            space_id = huggingface_hub.get_full_repo_name(to_id, token=hf_token)
+        else:
+            space_id = huggingface_hub.get_full_repo_name(
+                from_id.split("/")[1], token=hf_token
+            )
+        try:
+            huggingface_hub.get_space_runtime(space_id, token=hf_token)
+            if verbose:
+                print(
+                    f"Using your existing Space: {utils.SPACE_URL.format(space_id)} 🤗"
+                )
+            if secrets is not None:
+                warnings.warn(
+                    "Secrets are only used when the Space is duplicated for the first time, and are not updated if the duplicated Space already exists."
+                )
+        except RepositoryNotFoundError:
+            if verbose:
+                print(f"Creating a duplicate of {from_id} for your own use... 🤗")
+            huggingface_hub.duplicate_space(
+                from_id=from_id,
+                to_id=space_id,
+                token=hf_token,
+                exist_ok=True,
+                private=private,
+            )
+            if secrets is not None:
+                for key, value in secrets.items():
+                    huggingface_hub.add_space_secret(
+                        space_id, key, value, token=hf_token
+                    )
+            if verbose:
+                print(f"Created new Space: {utils.SPACE_URL.format(space_id)}")
+        current_info = huggingface_hub.get_space_runtime(space_id, token=hf_token)
+        current_hardware = (
+            current_info.hardware or huggingface_hub.SpaceHardware.CPU_BASIC
+        )
+        hardware = hardware or original_info.hardware
+        if current_hardware != hardware:
+            huggingface_hub.request_space_hardware(space_id, hardware)  # type: ignore
+            print(
+                f"-------\nNOTE: this Space uses upgraded hardware: {hardware}... see billing info at https://huggingface.co/settings/billing\n-------"
+            )
+        # Setting a timeout only works if the hardware is not basic
+        # so set it here after the hardware has been requested
+        if hardware != huggingface_hub.SpaceHardware.CPU_BASIC:
+            utils.set_space_timeout(
+                space_id, hf_token=hf_token, timeout_in_seconds=sleep_timeout * 60
+            )
+        if verbose:
+            print("")
+        client = cls(
+            space_id, hf_token=hf_token, max_workers=max_workers, verbose=verbose
+        )
+        return client
+
+    def _get_space_state(self):
+        if not self.space_id:
+            return None
+        info = huggingface_hub.get_space_runtime(self.space_id, token=self.hf_token)
+        return info.stage
+
+    def predict(
+        self,
+        *args,
+        api_name: str | None = None,
+        fn_index: int | None = None,
+    ) -> Any:
+        """
+        Calls the Gradio API and returns the result (this is a blocking call).
+
+        Parameters:
+            args: The arguments to pass to the remote API. The order of the arguments must match the order of the inputs in the Gradio app.
+            api_name: The name of the API endpoint to call starting with a leading slash, e.g. "/predict". Does not need to be provided if the Gradio app has only one named API endpoint.
+            fn_index: As an alternative to api_name, this parameter takes the index of the API endpoint to call, e.g. 0. Both api_name and fn_index can be provided, but if they conflict, api_name will take precedence.
+        Returns:
+            The result of the API call. Will be a Tuple if the API has multiple outputs.
+        Example:
+            from gradio_client import Client
+            client = Client(src="gradio/calculator")
+            client.predict(5, "add", 4, api_name="/predict")
+            >> 9.0
+        """
+        inferred_fn_index = self._infer_fn_index(api_name, fn_index)
+        if self.endpoints[inferred_fn_index].is_continuous:
+            raise ValueError(
+                "Cannot call predict on this function as it may run forever. Use submit instead."
+            )
+        return self.submit(*args, api_name=api_name, fn_index=fn_index).result()
+
+    def submit(
+        self,
+        *args,
+        api_name: str | None = None,
+        fn_index: int | None = None,
+        result_callbacks: Callable | list[Callable] | None = None,
+    ) -> Job:
+        """
+        Creates and returns a Job object which calls the Gradio API in a background thread. The job can be used to retrieve the status and result of the remote API call.
+
+        Parameters:
+            args: The arguments to pass to the remote API. The order of the arguments must match the order of the inputs in the Gradio app.
+            api_name: The name of the API endpoint to call starting with a leading slash, e.g. "/predict". Does not need to be provided if the Gradio app has only one named API endpoint.
+            fn_index: As an alternative to api_name, this parameter takes the index of the API endpoint to call, e.g. 0. Both api_name and fn_index can be provided, but if they conflict, api_name will take precedence.
+            result_callbacks: A callback function, or list of callback functions, to be called when the result is ready. If a list of functions is provided, they will be called in order. The return values from the remote API are provided as separate parameters into the callback. If None, no callback will be called.
+        Returns:
+            A Job object that can be used to retrieve the status and result of the remote API call.
+        Example:
+            from gradio_client import Client
+            client = Client(src="gradio/calculator")
+            job = client.submit(5, "add", 4, api_name="/predict")
+            job.status()
+            >> <Status.STARTING: 'STARTING'>
+            job.result()  # blocking call
+            >> 9.0
+        """
+        inferred_fn_index = self._infer_fn_index(api_name, fn_index)
+
+        helper = None
+        if self.endpoints[inferred_fn_index].use_ws:
+            helper = Communicator(
+                Lock(),
+                JobStatus(),
+                self.endpoints[inferred_fn_index].process_predictions,
+                self.reset_url,
+            )
+        end_to_end_fn = self.endpoints[inferred_fn_index].make_end_to_end_fn(helper)
+        future = self.executor.submit(end_to_end_fn, *args)
+
+        job = Job(
+            future, communicator=helper, verbose=self.verbose, space_id=self.space_id
+        )
+
+        if result_callbacks:
+            if isinstance(result_callbacks, Callable):
+                result_callbacks = [result_callbacks]
+
+            def create_fn(callback) -> Callable:
+                def fn(future):
+                    if isinstance(future.result(), tuple):
+                        callback(*future.result())
+                    else:
+                        callback(future.result())
+
+                return fn
+
+            for callback in result_callbacks:
+                job.add_done_callback(create_fn(callback))
+
+        return job
+
+    def view_api(
+        self,
+        all_endpoints: bool | None = None,
+        print_info: bool = True,
+        return_format: Literal["dict", "str"] | None = None,
+    ) -> dict | str | None:
+        """
+        Prints the usage info for the API. If the Gradio app has multiple API endpoints, the usage info for each endpoint will be printed separately. If return_format="dict" the info is returned in dictionary format, as shown in the example below.
+
+        Parameters:
+            all_endpoints: If True, prints information for both named and unnamed endpoints in the Gradio app. If False, will only print info about named endpoints. If None (default), will print info about named endpoints, unless there aren't any -- in which it will print info about unnamed endpoints.
+            print_info: If True, prints the usage info to the console. If False, does not print the usage info.
+            return_format: If None, nothing is returned. If "str", returns the same string that would be printed to the console. If "dict", returns the usage info as a dictionary that can be programmatically parsed, and *all endpoints are returned in the dictionary* regardless of the value of `all_endpoints`. The format of the dictionary is in the docstring of this method.
+        Example:
+            from gradio_client import Client
+            client = Client(src="gradio/calculator")
+            client.view_api(return_format="dict")
+            >> {
+                'named_endpoints': {
+                    '/predict': {
+                        'parameters': [
+                            {
+                                'label': 'num1',
+                                'type_python': 'int | float',
+                                'type_description': 'numeric value',
+                                'component': 'Number',
+                                'example_input': '5'
+                            },
+                            {
+                                'label': 'operation',
+                                'type_python': 'str',
+                                'type_description': 'string value',
+                                'component': 'Radio',
+                                'example_input': 'add'
+                            },
+                            {
+                                'label': 'num2',
+                                'type_python': 'int | float',
+                                'type_description': 'numeric value',
+                                'component': 'Number',
+                                'example_input': '5'
+                            },
+                        ],
+                        'returns': [
+                            {
+                                'label': 'output',
+                                'type_python': 'int | float',
+                                'type_description': 'numeric value',
+                                'component': 'Number',
+                            },
+                        ]
+                    },
+                    '/flag': {
+                        'parameters': [
+                            ...
+                            ],
+                        'returns': [
+                            ...
+                            ]
+                        }
+                    }
+                'unnamed_endpoints': {
+                    2: {
+                        'parameters': [
+                            ...
+                            ],
+                        'returns': [
+                            ...
+                            ]
+                        }
+                    }
+                }
+            }
+
+        """
+        if self.serialize:
+            api_info_url = urllib.parse.urljoin(self.src, utils.API_INFO_URL)
+        else:
+            api_info_url = urllib.parse.urljoin(self.src, utils.RAW_API_INFO_URL)
+
+        # Versions of Gradio older than 3.29.0 returned format of the API info
+        # from the /info endpoint
+        if version.parse(self.config.get("version", "2.0")) > version.Version("3.36.1"):
+            r = requests.get(api_info_url, headers=self.headers)
+            if r.ok:
+                info = r.json()
+            else:
+                raise ValueError(f"Could not fetch api info for {self.src}")
+        else:
+            fetch = requests.post(
+                utils.SPACE_FETCHER_URL,
+                json={"config": json.dumps(self.config), "serialize": self.serialize},
+            )
+            if fetch.ok:
+                info = fetch.json()["api"]
+            else:
+                raise ValueError(f"Could not fetch api info for {self.src}")
+        num_named_endpoints = len(info["named_endpoints"])
+        num_unnamed_endpoints = len(info["unnamed_endpoints"])
+        if num_named_endpoints == 0 and all_endpoints is None:
+            all_endpoints = True
+
+        human_info = "Client.predict() Usage Info\n---------------------------\n"
+        human_info += f"Named API endpoints: {num_named_endpoints}\n"
+
+        for api_name, endpoint_info in info["named_endpoints"].items():
+            human_info += self._render_endpoints_info(api_name, endpoint_info)
+
+        if all_endpoints:
+            human_info += f"\nUnnamed API endpoints: {num_unnamed_endpoints}\n"
+            for fn_index, endpoint_info in info["unnamed_endpoints"].items():
+                # When loading from json, the fn_indices are read as strings
+                # because json keys can only be strings
+                human_info += self._render_endpoints_info(int(fn_index), endpoint_info)
+        else:
+            if num_unnamed_endpoints > 0:
+                human_info += f"\nUnnamed API endpoints: {num_unnamed_endpoints}, to view, run Client.view_api(all_endpoints=True)\n"
+
+        if print_info:
+            print(human_info)
+        if return_format == "str":
+            return human_info
+        elif return_format == "dict":
+            return info
+
+    def reset_session(self) -> None:
+        self.session_hash = str(uuid.uuid4())
+
+    def _render_endpoints_info(
+        self,
+        name_or_index: str | int,
+        endpoints_info: dict[str, list[dict[str, Any]]],
+    ) -> str:
+        parameter_names = [p["label"] for p in endpoints_info["parameters"]]
+        parameter_names = [utils.sanitize_parameter_names(p) for p in parameter_names]
+        rendered_parameters = ", ".join(parameter_names)
+        if rendered_parameters:
+            rendered_parameters = rendered_parameters + ", "
+        return_values = [p["label"] for p in endpoints_info["returns"]]
+        return_values = [utils.sanitize_parameter_names(r) for r in return_values]
+        rendered_return_values = ", ".join(return_values)
+        if len(return_values) > 1:
+            rendered_return_values = f"({rendered_return_values})"
+
+        if isinstance(name_or_index, str):
+            final_param = f'api_name="{name_or_index}"'
+        elif isinstance(name_or_index, int):
+            final_param = f"fn_index={name_or_index}"
+        else:
+            raise ValueError("name_or_index must be a string or integer")
+
+        human_info = f"\n - predict({rendered_parameters}{final_param}) -> {rendered_return_values}\n"
+        human_info += "    Parameters:\n"
+        if endpoints_info["parameters"]:
+            for info in endpoints_info["parameters"]:
+                desc = (
+                    f" ({info['python_type']['description']})"
+                    if info["python_type"].get("description")
+                    else ""
+                )
+                type_ = info["python_type"]["type"]
+                human_info += f"     - [{info['component']}] {utils.sanitize_parameter_names(info['label'])}: {type_}{desc} \n"
+        else:
+            human_info += "     - None\n"
+        human_info += "    Returns:\n"
+        if endpoints_info["returns"]:
+            for info in endpoints_info["returns"]:
+                desc = (
+                    f" ({info['python_type']['description']})"
+                    if info["python_type"].get("description")
+                    else ""
+                )
+                type_ = info["python_type"]["type"]
+                human_info += f"     - [{info['component']}] {utils.sanitize_parameter_names(info['label'])}: {type_}{desc} \n"
+        else:
+            human_info += "     - None\n"
+
+        return human_info
+
+    def __repr__(self):
+        return self.view_api(print_info=False, return_format="str")
+
+    def __str__(self):
+        return self.view_api(print_info=False, return_format="str")
+
+    def _telemetry_thread(self) -> None:
+        # Disable telemetry by setting the env variable HF_HUB_DISABLE_TELEMETRY=1
+        data = {
+            "src": self.src,
+        }
+        try:
+            send_telemetry(
+                topic="py_client/initiated",
+                library_name="gradio_client",
+                library_version=utils.__version__,
+                user_agent=data,
+            )
+        except Exception:
+            pass
+
+    def _infer_fn_index(self, api_name: str | None, fn_index: int | None) -> int:
+        inferred_fn_index = None
+        if api_name is not None:
+            for i, d in enumerate(self.config["dependencies"]):
+                config_api_name = d.get("api_name")
+                if config_api_name is None or config_api_name is False:
+                    continue
+                if "/" + config_api_name == api_name:
+                    inferred_fn_index = i
+                    break
+            else:
+                error_message = f"Cannot find a function with `api_name`: {api_name}."
+                if not api_name.startswith("/"):
+                    error_message += " Did you mean to use a leading slash?"
+                raise ValueError(error_message)
+        elif fn_index is not None:
+            inferred_fn_index = fn_index
+            if (
+                inferred_fn_index >= len(self.endpoints)
+                or not self.endpoints[inferred_fn_index].is_valid
+            ):
+                raise ValueError(f"Invalid function index: {fn_index}.")
+        else:
+            valid_endpoints = [
+                e for e in self.endpoints if e.is_valid and e.api_name is not None
+            ]
+            if len(valid_endpoints) == 1:
+                inferred_fn_index = valid_endpoints[0].fn_index
+            else:
+                raise ValueError(
+                    "This Gradio app might have multiple endpoints. Please specify an `api_name` or `fn_index`"
+                )
+        return inferred_fn_index
+
+    def __del__(self):
+        if hasattr(self, "executor"):
+            self.executor.shutdown(wait=True)
+
+    def _space_name_to_src(self, space) -> str | None:
+        return huggingface_hub.space_info(space, token=self.hf_token).host  # type: ignore
+
+    def _get_config(self) -> dict:
+        r = requests.get(
+            urllib.parse.urljoin(self.src, utils.CONFIG_URL), headers=self.headers
+        )
+        if r.ok:
+            return r.json()
+        else:  # to support older versions of Gradio
+            r = requests.get(self.src, headers=self.headers)
+            # some basic regex to extract the config
+            result = re.search(r"window.gradio_config = (.*?);[\s]*</script>", r.text)
+            try:
+                config = json.loads(result.group(1))  # type: ignore
+            except AttributeError as ae:
+                raise ValueError(
+                    f"Could not get Gradio config from: {self.src}"
+                ) from ae
+            if "allow_flagging" in config:
+                raise ValueError(
+                    "Gradio 2.x is not supported by this client. Please upgrade your Gradio app to Gradio 3.x or higher."
+                )
+            return config
+
+    def deploy_discord(
+        self,
+        discord_bot_token: str | None = None,
+        api_names: list[str | tuple[str, str]] | None = None,
+        to_id: str | None = None,
+        hf_token: str | None = None,
+        private: bool = False,
+    ):
+        """
+        Deploy the upstream app as a discord bot. Currently only supports gr.ChatInterface.
+        Parameters:
+            discord_bot_token: This is the "password" needed to be able to launch the bot. Users can get a token by creating a bot app on the discord website. If run the method without specifying a token, the space will explain how to get one. See here: https://huggingface.co/spaces/freddyaboulton/test-discord-bot-v1.
+            api_names: The api_names of the app to turn into bot commands. This parameter currently has no effect as ChatInterface only has one api_name ('/chat').
+            to_id: The name of the space hosting the discord bot. If None, the name will be gradio-discord-bot-{random-substring}
+            hf_token: HF api token with write priviledges in order to upload the files to HF space. Can be ommitted if logged in via the HuggingFace CLI, unless the upstream space is private. Obtain from: https://huggingface.co/settings/token
+            private: Whether the space hosting the discord bot is private. The visibility of the discord bot itself is set via the discord website. See https://huggingface.co/spaces/freddyaboulton/test-discord-bot-v1
+        """
+
+        if self.config["mode"] == "chat_interface" and not api_names:
+            api_names = [("chat", "chat")]
+
+        valid_list = isinstance(api_names, list) and (
+            isinstance(n, str)
+            or (
+                isinstance(n, tuple) and isinstance(n[0], str) and isinstance(n[1], str)
+            )
+            for n in api_names
+        )
+        if api_names is None or not valid_list:
+            raise ValueError(
+                f"Each entry in api_names must be either a string or a tuple of strings. Received {api_names}"
+            )
+        assert (
+            len(api_names) == 1
+        ), "Currently only one api_name can be deployed to discord."
+
+        for i, name in enumerate(api_names):
+            if isinstance(name, str):
+                api_names[i] = (name, name)
+
+        fn = next(
+            (ep for ep in self.endpoints if ep.api_name == f"/{api_names[0][0]}"), None
+        )
+        if not fn:
+            raise ValueError(
+                f"api_name {api_names[0][0]} not present in {self.space_id or self.src}"
+            )
+        inputs = [
+            inp for inp in fn.input_component_types if fn not in utils.SKIP_COMPONENTS
+        ]
+        outputs = [
+            inp for inp in fn.input_component_types if fn not in utils.SKIP_COMPONENTS
+        ]
+        if not inputs == ["textbox"] and outputs == ["textbox"]:
+            raise ValueError(
+                "Currently only api_names with a single textbox as input and output are supported. "
+                f"Received {inputs} and {outputs}"
+            )
+
+        is_private = False
+        if self.space_id:
+            is_private = huggingface_hub.space_info(self.space_id).private
+            if is_private:
+                assert hf_token, (
+                    f"Since {self.space_id} is private, you must explicitly pass in hf_token "
+                    "so that it can be added as a secret in the discord bot space."
+                )
+
+        if to_id:
+            if "/" in to_id:
+                to_id = to_id.split("/")[1]
+            space_id = huggingface_hub.get_full_repo_name(to_id, token=hf_token)
+        else:
+            if self.space_id:
+                space_id = f'{self.space_id.split("/")[1]}-gradio-discord-bot'
+            else:
+                space_id = f"gradio-discord-bot-{secrets.token_hex(4)}"
+            space_id = huggingface_hub.get_full_repo_name(space_id, token=hf_token)
+
+        api = huggingface_hub.HfApi()
+
+        try:
+            huggingface_hub.space_info(space_id)
+            first_upload = False
+        except huggingface_hub.utils.RepositoryNotFoundError:
+            first_upload = True
+
+        huggingface_hub.create_repo(
+            space_id,
+            repo_type="space",
+            space_sdk="gradio",
+            token=hf_token,
+            exist_ok=True,
+            private=private,
+        )
+        if first_upload:
+            huggingface_hub.metadata_update(
+                repo_id=space_id,
+                repo_type="space",
+                metadata={"tags": ["gradio-discord-bot"]},
+            )
+
+        with open(str(Path(__file__).parent / "templates" / "discord_chat.py")) as f:
+            app = f.read()
+        app = app.replace("<<app-src>>", self.src)
+        app = app.replace("<<api-name>>", api_names[0][0])
+        app = app.replace("<<command-name>>", api_names[0][1])
+
+        with tempfile.NamedTemporaryFile(mode="w", delete=False) as app_file:
+            with tempfile.NamedTemporaryFile(mode="w", delete=False) as requirements:
+                app_file.write(app)
+                requirements.write("\n".join(["discord.py==2.3.1"]))
+
+        operations = [
+            CommitOperationAdd(path_in_repo="app.py", path_or_fileobj=app_file.name),
+            CommitOperationAdd(
+                path_in_repo="requirements.txt", path_or_fileobj=requirements.name
+            ),
+        ]
+
+        api.create_commit(
+            repo_id=space_id,
+            commit_message="Deploy Discord Bot",
+            repo_type="space",
+            operations=operations,
+            token=hf_token,
+        )
+
+        if discord_bot_token:
+            huggingface_hub.add_space_secret(
+                space_id, "DISCORD_TOKEN", discord_bot_token, token=hf_token
+            )
+        if is_private:
+            huggingface_hub.add_space_secret(
+                space_id, "HF_TOKEN", hf_token, token=hf_token
+            )
+
+        url = f"https://huggingface.co/spaces/{space_id}"
+        print(f"See your discord bot here! {url}")
+        return url
+
+
+class Endpoint:
+    """Helper class for storing all the information about a single API endpoint."""
+
+    def __init__(self, client: Client, fn_index: int, dependency: dict):
+        self.client: Client = client
+        self.fn_index = fn_index
+        self.dependency = dependency
+        api_name = dependency.get("api_name")
+        self.api_name: str | Literal[False] | None = (
+            "/" + api_name if isinstance(api_name, str) else api_name
+        )
+        self.use_ws = self._use_websocket(self.dependency)
+        self.input_component_types = []
+        self.output_component_types = []
+        self.root_url = client.src + "/" if not client.src.endswith("/") else client.src
+        self.is_continuous = dependency.get("types", {}).get("continuous", False)
+        try:
+            # Only a real API endpoint if backend_fn is True (so not just a frontend function), serializers are valid,
+            # and api_name is not False (meaning that the developer has explicitly disabled the API endpoint)
+            self.serializers, self.deserializers = self._setup_serializers()
+            self.is_valid = self.dependency["backend_fn"] and self.api_name is not False
+        except AssertionError:
+            self.is_valid = False
+
+    def __repr__(self):
+        return f"Endpoint src: {self.client.src}, api_name: {self.api_name}, fn_index: {self.fn_index}"
+
+    def __str__(self):
+        return self.__repr__()
+
+    def make_end_to_end_fn(self, helper: Communicator | None = None):
+        _predict = self.make_predict(helper)
+
+        def _inner(*data):
+            if not self.is_valid:
+                raise utils.InvalidAPIEndpointError()
+            data = self.insert_state(*data)
+            if self.client.serialize:
+                data = self.serialize(*data)
+            predictions = _predict(*data)
+            predictions = self.process_predictions(*predictions)
+            # Append final output only if not already present
+            # for consistency between generators and not generators
+            if helper:
+                with helper.lock:
+                    if not helper.job.outputs:
+                        helper.job.outputs.append(predictions)
+            return predictions
+
+        return _inner
+
+    def make_predict(self, helper: Communicator | None = None):
+        def _predict(*data) -> tuple:
+            data = json.dumps(
+                {
+                    "data": data,
+                    "fn_index": self.fn_index,
+                    "session_hash": self.client.session_hash,
+                }
+            )
+            hash_data = json.dumps(
+                {
+                    "fn_index": self.fn_index,
+                    "session_hash": self.client.session_hash,
+                }
+            )
+
+            if self.use_ws:
+                result = utils.synchronize_async(self._ws_fn, data, hash_data, helper)
+                if "error" in result:
+                    raise ValueError(result["error"])
+            else:
+                response = requests.post(
+                    self.client.api_url, headers=self.client.headers, data=data
+                )
+                result = json.loads(response.content.decode("utf-8"))
+            try:
+                output = result["data"]
+            except KeyError as ke:
+                is_public_space = (
+                    self.client.space_id
+                    and not huggingface_hub.space_info(self.client.space_id).private
+                )
+                if "error" in result and "429" in result["error"] and is_public_space:
+                    raise utils.TooManyRequestsError(
+                        f"Too many requests to the API, please try again later. To avoid being rate-limited, "
+                        f"please duplicate the Space using Client.duplicate({self.client.space_id}) "
+                        f"and pass in your Hugging Face token."
+                    ) from None
+                elif "error" in result:
+                    raise ValueError(result["error"]) from None
+                raise KeyError(
+                    f"Could not find 'data' key in response. Response received: {result}"
+                ) from ke
+            return tuple(output)
+
+        return _predict
+
+    def _predict_resolve(self, *data) -> Any:
+        """Needed for gradio.load(), which has a slightly different signature for serializing/deserializing"""
+        outputs = self.make_predict()(*data)
+        if len(self.dependency["outputs"]) == 1:
+            return outputs[0]
+        return outputs
+
+    def _upload(
+        self, file_paths: list[str | list[str]]
+    ) -> list[str | list[str]] | list[dict[str, Any] | list[dict[str, Any]]]:
+        if not file_paths:
+            return []
+        # Put all the filepaths in one file
+        # but then keep track of which index in the
+        # original list they came from so we can recreate
+        # the original structure
+        files = []
+        indices = []
+        for i, fs in enumerate(file_paths):
+            if not isinstance(fs, list):
+                fs = [fs]
+            for f in fs:
+                files.append(("files", (Path(f).name, open(f, "rb"))))  # noqa: SIM115
+                indices.append(i)
+        r = requests.post(
+            self.client.upload_url, headers=self.client.headers, files=files
+        )
+        if r.status_code != 200:
+            uploaded = file_paths
+        else:
+            uploaded = []
+            result = r.json()
+            for i, fs in enumerate(file_paths):
+                if isinstance(fs, list):
+                    output = [o for ix, o in enumerate(result) if indices[ix] == i]
+                    res = [
+                        {
+                            "is_file": True,
+                            "name": o,
+                            "orig_name": Path(f).name,
+                            "data": None,
+                        }
+                        for f, o in zip(fs, output)
+                    ]
+                else:
+                    o = next(o for ix, o in enumerate(result) if indices[ix] == i)
+                    res = {
+                        "is_file": True,
+                        "name": o,
+                        "orig_name": Path(fs).name,
+                        "data": None,
+                    }
+                uploaded.append(res)
+        return uploaded
+
+    def _add_uploaded_files_to_data(
+        self,
+        files: list[str | list[str]] | list[dict[str, Any] | list[dict[str, Any]]],
+        data: list[Any],
+    ) -> None:
+        """Helper function to modify the input data with the uploaded files."""
+        file_counter = 0
+        for i, t in enumerate(self.input_component_types):
+            if t in ["file", "uploadbutton"]:
+                data[i] = files[file_counter]
+                file_counter += 1
+
+    def insert_state(self, *data) -> tuple:
+        data = list(data)
+        for i, input_component_type in enumerate(self.input_component_types):
+            if input_component_type == utils.STATE_COMPONENT:
+                data.insert(i, None)
+        return tuple(data)
+
+    def remove_skipped_components(self, *data) -> tuple:
+        data = [
+            d
+            for d, oct in zip(data, self.output_component_types)
+            if oct not in utils.SKIP_COMPONENTS
+        ]
+        return tuple(data)
+
+    def reduce_singleton_output(self, *data) -> Any:
+        if (
+            len(
+                [
+                    oct
+                    for oct in self.output_component_types
+                    if oct not in utils.SKIP_COMPONENTS
+                ]
+            )
+            == 1
+        ):
+            return data[0]
+        else:
+            return data
+
+    def serialize(self, *data) -> tuple:
+        assert len(data) == len(
+            self.serializers
+        ), f"Expected {len(self.serializers)} arguments, got {len(data)}"
+
+        files = [
+            f
+            for f, t in zip(data, self.input_component_types)
+            if t in ["file", "uploadbutton"]
+        ]
+        uploaded_files = self._upload(files)
+        data = list(data)
+        self._add_uploaded_files_to_data(uploaded_files, data)
+        o = tuple([s.serialize(d) for s, d in zip(self.serializers, data)])
+        return o
+
+    def deserialize(self, *data) -> tuple:
+        assert len(data) == len(
+            self.deserializers
+        ), f"Expected {len(self.deserializers)} outputs, got {len(data)}"
+        outputs = tuple(
+            [
+                s.deserialize(
+                    d,
+                    save_dir=self.client.output_dir,
+                    hf_token=self.client.hf_token,
+                    root_url=self.root_url,
+                )
+                for s, d in zip(self.deserializers, data)
+            ]
+        )
+        return outputs
+
+    def process_predictions(self, *predictions):
+        if self.client.serialize:
+            predictions = self.deserialize(*predictions)
+        predictions = self.remove_skipped_components(*predictions)
+        predictions = self.reduce_singleton_output(*predictions)
+        return predictions
+
+    def _setup_serializers(self) -> tuple[list[Serializable], list[Serializable]]:
+        inputs = self.dependency["inputs"]
+        serializers = []
+
+        for i in inputs:
+            for component in self.client.config["components"]:
+                if component["id"] == i:
+                    component_name = component["type"]
+                    self.input_component_types.append(component_name)
+                    if component.get("serializer"):
+                        serializer_name = component["serializer"]
+                        assert (
+                            serializer_name in serializing.SERIALIZER_MAPPING
+                        ), f"Unknown serializer: {serializer_name}, you may need to update your gradio_client version."
+                        serializer = serializing.SERIALIZER_MAPPING[serializer_name]
+                    else:
+                        assert (
+                            component_name in serializing.COMPONENT_MAPPING
+                        ), f"Unknown component: {component_name}, you may need to update your gradio_client version."
+                        serializer = serializing.COMPONENT_MAPPING[component_name]
+                    serializers.append(serializer())  # type: ignore
+
+        outputs = self.dependency["outputs"]
+        deserializers = []
+        for i in outputs:
+            for component in self.client.config["components"]:
+                if component["id"] == i:
+                    component_name = component["type"]
+                    self.output_component_types.append(component_name)
+                    if component.get("serializer"):
+                        serializer_name = component["serializer"]
+                        assert (
+                            serializer_name in serializing.SERIALIZER_MAPPING
+                        ), f"Unknown serializer: {serializer_name}, you may need to update your gradio_client version."
+                        deserializer = serializing.SERIALIZER_MAPPING[serializer_name]
+                    elif component_name in utils.SKIP_COMPONENTS:
+                        deserializer = serializing.SimpleSerializable
+                    else:
+                        assert (
+                            component_name in serializing.COMPONENT_MAPPING
+                        ), f"Unknown component: {component_name}, you may need to update your gradio_client version."
+                        deserializer = serializing.COMPONENT_MAPPING[component_name]
+                    deserializers.append(deserializer())  # type: ignore
+
+        return serializers, deserializers
+
+    def _use_websocket(self, dependency: dict) -> bool:
+        queue_enabled = self.client.config.get("enable_queue", False)
+        queue_uses_websocket = version.parse(
+            self.client.config.get("version", "2.0")
+        ) >= version.Version("3.2")
+        dependency_uses_queue = dependency.get("queue", False) is not False
+        return queue_enabled and queue_uses_websocket and dependency_uses_queue
+
+    async def _ws_fn(self, data, hash_data, helper: Communicator):
+        async with websockets.connect(  # type: ignore
+            self.client.ws_url,
+            open_timeout=10,
+            extra_headers=self.client.headers,
+            max_size=1024 * 1024 * 1024,
+        ) as websocket:
+            return await utils.get_pred_from_ws(websocket, data, hash_data, helper)
+
+
+@document("result", "outputs", "status")
+class Job(Future):
+    """
+    A Job is a wrapper over the Future class that represents a prediction call that has been
+    submitted by the Gradio client. This class is not meant to be instantiated directly, but rather
+    is created by the Client.submit() method.
+
+    A Job object includes methods to get the status of the prediction call, as well to get the outputs of
+    the prediction call. Job objects are also iterable, and can be used in a loop to get the outputs
+    of prediction calls as they become available for generator endpoints.
+    """
+
+    def __init__(
+        self,
+        future: Future,
+        communicator: Communicator | None = None,
+        verbose: bool = True,
+        space_id: str | None = None,
+    ):
+        """
+        Parameters:
+            future: The future object that represents the prediction call, created by the Client.submit() method
+            communicator: The communicator object that is used to communicate between the client and the background thread running the job
+            verbose: Whether to print any status-related messages to the console
+            space_id: The space ID corresponding to the Client object that created this Job object
+        """
+        self.future = future
+        self.communicator = communicator
+        self._counter = 0
+        self.verbose = verbose
+        self.space_id = space_id
+
+    def __iter__(self) -> Job:
+        return self
+
+    def __next__(self) -> tuple | Any:
+        if not self.communicator:
+            raise StopIteration()
+
+        with self.communicator.lock:
+            if self.communicator.job.latest_status.code == Status.FINISHED:
+                raise StopIteration()
+
+        while True:
+            with self.communicator.lock:
+                if len(self.communicator.job.outputs) == self._counter + 1:
+                    o = self.communicator.job.outputs[self._counter]
+                    self._counter += 1
+                    return o
+                if self.communicator.job.latest_status.code == Status.FINISHED:
+                    raise StopIteration()
+
+    def result(self, timeout: float | None = None) -> Any:
+        """
+        Return the result of the call that the future represents. Raises CancelledError: If the future was cancelled, TimeoutError: If the future didn't finish executing before the given timeout, and Exception: If the call raised then that exception will be raised.
+
+        Parameters:
+            timeout: The number of seconds to wait for the result if the future isn't done. If None, then there is no limit on the wait time.
+        Returns:
+            The result of the call that the future represents. For generator functions, it will return the final iteration.
+        Example:
+            from gradio_client import Client
+            calculator = Client(src="gradio/calculator")
+            job = calculator.submit("foo", "add", 4, fn_index=0)
+            job.result(timeout=5)
+            >> 9
+        """
+        return super().result(timeout=timeout)
+
+    def outputs(self) -> list[tuple | Any]:
+        """
+        Returns a list containing the latest outputs from the Job.
+
+        If the endpoint has multiple output components, the list will contain
+        a tuple of results. Otherwise, it will contain the results without storing them
+        in tuples.
+
+        For endpoints that are queued, this list will contain the final job output even
+        if that endpoint does not use a generator function.
+
+        Example:
+            from gradio_client import Client
+            client = Client(src="gradio/count_generator")
+            job = client.submit(3, api_name="/count")
+            while not job.done():
+                time.sleep(0.1)
+            job.outputs()
+            >> ['0', '1', '2']
+        """
+        if not self.communicator:
+            return []
+        else:
+            with self.communicator.lock:
+                return self.communicator.job.outputs
+
+    def status(self) -> StatusUpdate:
+        """
+        Returns the latest status update from the Job in the form of a StatusUpdate
+        object, which contains the following fields: code, rank, queue_size, success, time, eta, and progress_data.
+
+        progress_data is a list of updates emitted by the gr.Progress() tracker of the event handler. Each element
+        of the list has the following fields: index, length, unit, progress, desc. If the event handler does not have
+        a gr.Progress() tracker, the progress_data field will be None.
+
+        Example:
+            from gradio_client import Client
+            client = Client(src="gradio/calculator")
+            job = client.submit(5, "add", 4, api_name="/predict")
+            job.status()
+            >> <Status.STARTING: 'STARTING'>
+            job.status().eta
+            >> 43.241  # seconds
+        """
+        time = datetime.now()
+        cancelled = False
+        if self.communicator:
+            with self.communicator.lock:
+                cancelled = self.communicator.should_cancel
+        if cancelled:
+            return StatusUpdate(
+                code=Status.CANCELLED,
+                rank=0,
+                queue_size=None,
+                success=False,
+                time=time,
+                eta=None,
+                progress_data=None,
+            )
+        if self.done():
+            if not self.future._exception:  # type: ignore
+                return StatusUpdate(
+                    code=Status.FINISHED,
+                    rank=0,
+                    queue_size=None,
+                    success=True,
+                    time=time,
+                    eta=None,
+                    progress_data=None,
+                )
+            else:
+                return StatusUpdate(
+                    code=Status.FINISHED,
+                    rank=0,
+                    queue_size=None,
+                    success=False,
+                    time=time,
+                    eta=None,
+                    progress_data=None,
+                )
+        else:
+            if not self.communicator:
+                return StatusUpdate(
+                    code=Status.PROCESSING,
+                    rank=0,
+                    queue_size=None,
+                    success=None,
+                    time=time,
+                    eta=None,
+                    progress_data=None,
+                )
+            else:
+                with self.communicator.lock:
+                    eta = self.communicator.job.latest_status.eta
+                    if self.verbose and self.space_id and eta and eta > 30:
+                        print(
+                            f"Due to heavy traffic on this app, the prediction will take approximately {int(eta)} seconds."
+                            f"For faster predictions without waiting in queue, you may duplicate the space using: Client.duplicate({self.space_id})"
+                        )
+                    return self.communicator.job.latest_status
+
+    def __getattr__(self, name):
+        """Forwards any properties to the Future class."""
+        return getattr(self.future, name)
+
+    def cancel(self) -> bool:
+        """Cancels the job as best as possible.
+
+        If the app you are connecting to has the gradio queue enabled, the job
+        will be cancelled locally as soon as possible. For apps that do not use the
+        queue, the job cannot be cancelled if it's been sent to the local executor
+        (for the time being).
+
+        Note: In general, this DOES not stop the process from running in the upstream server
+        except for the following situations:
+
+        1. If the job is queued upstream, it will be removed from the queue and the server will not run the job
+        2. If the job has iterative outputs, the job will finish as soon as the current iteration finishes running
+        3. If the job has not been picked up by the queue yet, the queue will not pick up the job
+        """
+        if self.communicator:
+            with self.communicator.lock:
+                self.communicator.should_cancel = True
+                return True
+        return self.future.cancel()

testbed/gradio-app__gradio/client/python/gradio_client/data_classes.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from typing import TypedDict
+
+from typing_extensions import NotRequired
+
+
+class FileData(TypedDict):
+    name: str | None  # filename
+    data: str | None  # base64 encoded data
+    size: NotRequired[int | None]  # size in bytes
+    is_file: NotRequired[
+        bool
+    ]  # whether the data corresponds to a file or base64 encoded data
+    orig_name: NotRequired[str]  # original filename
+    mime_type: NotRequired[str]
+    is_stream: NotRequired[bool]

testbed/gradio-app__gradio/client/python/gradio_client/documentation.py

@@ -0,0 +1,266 @@
+"""Contains methods that generate documentation for Gradio functions and classes."""
+
+from __future__ import annotations
+
+import inspect
+from typing import Callable
+
+classes_to_document = {}
+classes_inherit_documentation = {}
+documentation_group = None
+
+
+def set_documentation_group(m):
+    global documentation_group
+    documentation_group = m
+    if m not in classes_to_document:
+        classes_to_document[m] = []
+
+
+def extract_instance_attr_doc(cls, attr):
+    code = inspect.getsource(cls.__init__)
+    lines = [line.strip() for line in code.split("\n")]
+    i = None
+    for i, line in enumerate(lines):  # noqa: B007
+        if line.startswith("self." + attr + ":") or line.startswith(
+            "self." + attr + " ="
+        ):
+            break
+    assert i is not None, f"Could not find {attr} in {cls.__name__}"
+    start_line = lines.index('"""', i)
+    end_line = lines.index('"""', start_line + 1)
+    for j in range(i + 1, start_line):
+        assert not lines[j].startswith("self."), (
+            f"Found another attribute before docstring for {attr} in {cls.__name__}: "
+            + lines[j]
+            + "\n start:"
+            + lines[i]
+        )
+    doc_string = " ".join(lines[start_line + 1 : end_line])
+    return doc_string
+
+
+def document(*fns, inherit=False):
+    """
+    Defines the @document decorator which adds classes or functions to the Gradio
+    documentation at www.gradio.app/docs.
+
+    Usage examples:
+    - Put @document() above a class to document the class and its constructor.
+    - Put @document("fn1", "fn2") above a class to also document methods fn1 and fn2.
+    - Put @document("*fn3") with an asterisk above a class to document the instance attribute methods f3.
+    """
+
+    def inner_doc(cls):
+        global documentation_group
+        if inherit:
+            classes_inherit_documentation[cls] = None
+        classes_to_document[documentation_group].append((cls, fns))
+        return cls
+
+    return inner_doc
+
+
+def document_fn(fn: Callable, cls) -> tuple[str, list[dict], dict, str | None]:
+    """
+    Generates documentation for any function.
+    Parameters:
+        fn: Function to document
+    Returns:
+        description: General description of fn
+        parameters: A list of dicts for each parameter, storing data for the parameter name, annotation and doc
+        return: A dict storing data for the returned annotation and doc
+        example: Code for an example use of the fn
+    """
+    doc_str = inspect.getdoc(fn) or ""
+    doc_lines = doc_str.split("\n")
+    signature = inspect.signature(fn)
+    description, parameters, returns, examples = [], {}, [], []
+    mode = "description"
+    for line in doc_lines:
+        line = line.rstrip()
+        if line == "Parameters:":
+            mode = "parameter"
+        elif line.startswith("Example:"):
+            mode = "example"
+            if "(" in line and ")" in line:
+                c = line.split("(")[1].split(")")[0]
+                if c != cls.__name__:
+                    mode = "ignore"
+        elif line == "Returns:":
+            mode = "return"
+        else:
+            if mode == "description":
+                description.append(line if line.strip() else "<br>")
+                continue
+            if not (line.startswith("    ") or line.strip() == ""):
+                print(line)
+            assert (
+                line.startswith("    ") or line.strip() == ""
+            ), f"Documentation format for {fn.__name__} has format error in line: {line}"
+            line = line[4:]
+            if mode == "parameter":
+                colon_index = line.index(": ")
+                assert (
+                    colon_index > -1
+                ), f"Documentation format for {fn.__name__} has format error in line: {line}"
+                parameter = line[:colon_index]
+                parameter_doc = line[colon_index + 2 :]
+                parameters[parameter] = parameter_doc
+            elif mode == "return":
+                returns.append(line)
+            elif mode == "example":
+                examples.append(line)
+    description_doc = " ".join(description)
+    parameter_docs = []
+    for param_name, param in signature.parameters.items():
+        if param_name.startswith("_"):
+            continue
+        if param_name in ["kwargs", "args"] and param_name not in parameters:
+            continue
+        parameter_doc = {
+            "name": param_name,
+            "annotation": param.annotation,
+            "doc": parameters.get(param_name),
+        }
+        if param_name in parameters:
+            del parameters[param_name]
+        if param.default != inspect.Parameter.empty:
+            default = param.default
+            if type(default) == str:
+                default = '"' + default + '"'
+            if default.__class__.__module__ != "builtins":
+                default = f"{default.__class__.__name__}()"
+            parameter_doc["default"] = default
+        elif parameter_doc["doc"] is not None:
+            if "kwargs" in parameter_doc["doc"]:
+                parameter_doc["kwargs"] = True
+            if "args" in parameter_doc["doc"]:
+                parameter_doc["args"] = True
+        parameter_docs.append(parameter_doc)
+    assert (
+        len(parameters) == 0
+    ), f"Documentation format for {fn.__name__} documents nonexistent parameters: {''.join(parameters.keys())}"
+    if len(returns) == 0:
+        return_docs = {}
+    elif len(returns) == 1:
+        return_docs = {"annotation": signature.return_annotation, "doc": returns[0]}
+    else:
+        return_docs = {}
+        # raise ValueError("Does not support multiple returns yet.")
+    examples_doc = "\n".join(examples) if len(examples) > 0 else None
+    return description_doc, parameter_docs, return_docs, examples_doc
+
+
+def document_cls(cls):
+    doc_str = inspect.getdoc(cls)
+    if doc_str is None:
+        return "", {}, ""
+    tags = {}
+    description_lines = []
+    mode = "description"
+    for line in doc_str.split("\n"):
+        line = line.rstrip()
+        if line.endswith(":") and " " not in line:
+            mode = line[:-1].lower()
+            tags[mode] = []
+        elif line.split(" ")[0].endswith(":") and not line.startswith("    "):
+            tag = line[: line.index(":")].lower()
+            value = line[line.index(":") + 2 :]
+            tags[tag] = value
+        else:
+            if mode == "description":
+                description_lines.append(line if line.strip() else "<br>")
+            else:
+                assert (
+                    line.startswith("    ") or not line.strip()
+                ), f"Documentation format for {cls.__name__} has format error in line: {line}"
+                tags[mode].append(line[4:])
+    if "example" in tags:
+        example = "\n".join(tags["example"])
+        del tags["example"]
+    else:
+        example = None
+    for key, val in tags.items():
+        if isinstance(val, list):
+            tags[key] = "<br>".join(val)
+    description = " ".join(description_lines).replace("\n", "<br>")
+    return description, tags, example
+
+
+def generate_documentation():
+    documentation = {}
+    for mode, class_list in classes_to_document.items():
+        documentation[mode] = []
+        for cls, fns in class_list:
+            fn_to_document = cls if inspect.isfunction(cls) else cls.__init__
+            _, parameter_doc, return_doc, _ = document_fn(fn_to_document, cls)
+            cls_description, cls_tags, cls_example = document_cls(cls)
+            cls_documentation = {
+                "class": cls,
+                "name": cls.__name__,
+                "description": cls_description,
+                "tags": cls_tags,
+                "parameters": parameter_doc,
+                "returns": return_doc,
+                "example": cls_example,
+                "fns": [],
+            }
+            for fn_name in fns:
+                instance_attribute_fn = fn_name.startswith("*")
+                if instance_attribute_fn:
+                    fn_name = fn_name[1:]
+                    # Instance attribute fns are classes
+                    # whose __call__ method determines their behavior
+                    fn = getattr(cls(), fn_name).__call__
+                else:
+                    fn = getattr(cls, fn_name)
+                if not callable(fn):
+                    description_doc = str(fn)
+                    parameter_docs = {}
+                    return_docs = {}
+                    examples_doc = ""
+                    override_signature = f"gr.{cls.__name__}.{fn_name}"
+                else:
+                    (
+                        description_doc,
+                        parameter_docs,
+                        return_docs,
+                        examples_doc,
+                    ) = document_fn(fn, cls)
+                    override_signature = None
+                if instance_attribute_fn:
+                    description_doc = extract_instance_attr_doc(cls, fn_name)
+                cls_documentation["fns"].append(
+                    {
+                        "fn": fn,
+                        "name": fn_name,
+                        "description": description_doc,
+                        "tags": {},
+                        "parameters": parameter_docs,
+                        "returns": return_docs,
+                        "example": examples_doc,
+                        "override_signature": override_signature,
+                    }
+                )
+            documentation[mode].append(cls_documentation)
+            if cls in classes_inherit_documentation:
+                classes_inherit_documentation[cls] = cls_documentation["fns"]
+    for mode, class_list in classes_to_document.items():
+        for i, (cls, _) in enumerate(class_list):
+            for super_class in classes_inherit_documentation:
+                if (
+                    inspect.isclass(cls)
+                    and issubclass(cls, super_class)
+                    and cls != super_class
+                ):
+                    for inherited_fn in classes_inherit_documentation[super_class]:
+                        inherited_fn = dict(inherited_fn)
+                        try:
+                            inherited_fn["description"] = extract_instance_attr_doc(
+                                cls, inherited_fn["name"]
+                            )
+                        except (ValueError, AssertionError):
+                            pass
+                        documentation[mode][i]["fns"].append(inherited_fn)
+    return documentation

testbed/gradio-app__gradio/client/python/gradio_client/package.json

@@ -0,0 +1,7 @@
+{
+	"name": "gradio_client",
+	"version": "0.5.2",
+	"description": "",
+	"python": "true",
+	"main_changeset": true
+}

testbed/gradio-app__gradio/client/python/gradio_client/serializing.py

@@ -0,0 +1,582 @@
+from __future__ import annotations
+
+import json
+import os
+import secrets
+import tempfile
+import uuid
+from pathlib import Path
+from typing import Any
+
+from gradio_client import media_data, utils
+from gradio_client.data_classes import FileData
+
+with open(Path(__file__).parent / "types.json") as f:
+    serializer_types = json.load(f)
+
+
+class Serializable:
+    def serialized_info(self):
+        """
+        The typing information for this component as a dictionary whose values are a list of 2 strings: [Python type, language-agnostic description].
+        Keys of the dictionary are: raw_input, raw_output, serialized_input, serialized_output
+        """
+        return self.api_info()
+
+    def api_info(self) -> dict[str, list[str]]:
+        """
+        The typing information for this component as a dictionary whose values are a list of 2 strings: [Python type, language-agnostic description].
+        Keys of the dictionary are: raw_input, raw_output, serialized_input, serialized_output
+        """
+        raise NotImplementedError()
+
+    def example_inputs(self) -> dict[str, Any]:
+        """
+        The example inputs for this component as a dictionary whose values are example inputs compatible with this component.
+        Keys of the dictionary are: raw, serialized
+        """
+        raise NotImplementedError()
+
+    # For backwards compatibility
+    def input_api_info(self) -> tuple[str, str]:
+        api_info = self.api_info()
+        types = api_info.get("serialized_input", [api_info["info"]["type"]] * 2)  # type: ignore
+        return (types[0], types[1])
+
+    # For backwards compatibility
+    def output_api_info(self) -> tuple[str, str]:
+        api_info = self.api_info()
+        types = api_info.get("serialized_output", [api_info["info"]["type"]] * 2)  # type: ignore
+        return (types[0], types[1])
+
+    def serialize(self, x: Any, load_dir: str | Path = "", allow_links: bool = False):
+        """
+        Convert data from human-readable format to serialized format for a browser.
+        """
+        return x
+
+    def deserialize(
+        self,
+        x: Any,
+        save_dir: str | Path | None = None,
+        root_url: str | None = None,
+        hf_token: str | None = None,
+    ):
+        """
+        Convert data from serialized format for a browser to human-readable format.
+        """
+        return x
+
+
+class SimpleSerializable(Serializable):
+    """General class that does not perform any serialization or deserialization."""
+
+    def api_info(self) -> dict[str, bool | dict]:
+        return {
+            "info": serializer_types["SimpleSerializable"],
+            "serialized_info": False,
+        }
+
+    def example_inputs(self) -> dict[str, Any]:
+        return {
+            "raw": None,
+            "serialized": None,
+        }
+
+
+class StringSerializable(Serializable):
+    """Expects a string as input/output but performs no serialization."""
+
+    def api_info(self) -> dict[str, bool | dict]:
+        return {
+            "info": serializer_types["StringSerializable"],
+            "serialized_info": False,
+        }
+
+    def example_inputs(self) -> dict[str, Any]:
+        return {
+            "raw": "Howdy!",
+            "serialized": "Howdy!",
+        }
+
+
+class ListStringSerializable(Serializable):
+    """Expects a list of strings as input/output but performs no serialization."""
+
+    def api_info(self) -> dict[str, bool | dict]:
+        return {
+            "info": serializer_types["ListStringSerializable"],
+            "serialized_info": False,
+        }
+
+    def example_inputs(self) -> dict[str, Any]:
+        return {
+            "raw": ["Howdy!", "Merhaba"],
+            "serialized": ["Howdy!", "Merhaba"],
+        }
+
+
+class BooleanSerializable(Serializable):
+    """Expects a boolean as input/output but performs no serialization."""
+
+    def api_info(self) -> dict[str, bool | dict]:
+        return {
+            "info": serializer_types["BooleanSerializable"],
+            "serialized_info": False,
+        }
+
+    def example_inputs(self) -> dict[str, Any]:
+        return {
+            "raw": True,
+            "serialized": True,
+        }
+
+
+class NumberSerializable(Serializable):
+    """Expects a number (int/float) as input/output but performs no serialization."""
+
+    def api_info(self) -> dict[str, bool | dict]:
+        return {
+            "info": serializer_types["NumberSerializable"],
+            "serialized_info": False,
+        }
+
+    def example_inputs(self) -> dict[str, Any]:
+        return {
+            "raw": 5,
+            "serialized": 5,
+        }
+
+
+class ImgSerializable(Serializable):
+    """Expects a base64 string as input/output which is serialized to a filepath."""
+
+    def serialized_info(self):
+        return {"type": "string", "description": "filepath or URL to image"}
+
+    def api_info(self) -> dict[str, bool | dict]:
+        return {"info": serializer_types["ImgSerializable"], "serialized_info": True}
+
+    def example_inputs(self) -> dict[str, Any]:
+        return {
+            "raw": media_data.BASE64_IMAGE,
+            "serialized": "https://raw.githubusercontent.com/gradio-app/gradio/main/test/test_files/bus.png",
+        }
+
+    def serialize(
+        self,
+        x: str | None,
+        load_dir: str | Path = "",
+        allow_links: bool = False,
+    ) -> str | None:
+        """
+        Convert from human-friendly version of a file (string filepath) to a serialized
+        representation (base64).
+        Parameters:
+            x: String path to file to serialize
+            load_dir: Path to directory containing x
+        """
+        if not x:
+            return None
+        if utils.is_http_url_like(x):
+            return utils.encode_url_to_base64(x)
+        return utils.encode_file_to_base64(Path(load_dir) / x)
+
+    def deserialize(
+        self,
+        x: str | None,
+        save_dir: str | Path | None = None,
+        root_url: str | None = None,
+        hf_token: str | None = None,
+    ) -> str | None:
+        """
+        Convert from serialized representation of a file (base64) to a human-friendly
+        version (string filepath). Optionally, save the file to the directory specified by save_dir
+        Parameters:
+            x: Base64 representation of image to deserialize into a string filepath
+            save_dir: Path to directory to save the deserialized image to
+            root_url: Ignored
+            hf_token: Ignored
+        """
+        if x is None or x == "":
+            return None
+        file = utils.decode_base64_to_file(x, dir=save_dir)
+        return file.name
+
+
+class FileSerializable(Serializable):
+    """Expects a dict with base64 representation of object as input/output which is serialized to a filepath."""
+
+    def __init__(self) -> None:
+        self.stream = None
+        self.stream_name = None
+        super().__init__()
+
+    def serialized_info(self):
+        return self._single_file_serialized_info()
+
+    def _single_file_api_info(self):
+        return {
+            "info": serializer_types["SingleFileSerializable"],
+            "serialized_info": True,
+        }
+
+    def _single_file_serialized_info(self):
+        return {"type": "string", "description": "filepath or URL to file"}
+
+    def _multiple_file_serialized_info(self):
+        return {
+            "type": "array",
+            "description": "List of filepath(s) or URL(s) to files",
+            "items": {"type": "string", "description": "filepath or URL to file"},
+        }
+
+    def _multiple_file_api_info(self):
+        return {
+            "info": serializer_types["MultipleFileSerializable"],
+            "serialized_info": True,
+        }
+
+    def api_info(self) -> dict[str, dict | bool]:
+        return self._single_file_api_info()
+
+    def example_inputs(self) -> dict[str, Any]:
+        return self._single_file_example_inputs()
+
+    def _single_file_example_inputs(self) -> dict[str, Any]:
+        return {
+            "raw": {"is_file": False, "data": media_data.BASE64_FILE},
+            "serialized": "https://github.com/gradio-app/gradio/raw/main/test/test_files/sample_file.pdf",
+        }
+
+    def _multiple_file_example_inputs(self) -> dict[str, Any]:
+        return {
+            "raw": [{"is_file": False, "data": media_data.BASE64_FILE}],
+            "serialized": [
+                "https://github.com/gradio-app/gradio/raw/main/test/test_files/sample_file.pdf"
+            ],
+        }
+
+    def _serialize_single(
+        self,
+        x: str | FileData | None,
+        load_dir: str | Path = "",
+        allow_links: bool = False,
+    ) -> FileData | None:
+        if x is None or isinstance(x, dict):
+            return x
+        if utils.is_http_url_like(x):
+            filename = x
+            size = None
+        else:
+            filename = str(Path(load_dir) / x)
+            size = Path(filename).stat().st_size
+        return {
+            "name": filename,
+            "data": None
+            if allow_links
+            else utils.encode_url_or_file_to_base64(filename),
+            "orig_name": Path(filename).name,
+            "is_file": allow_links,
+            "size": size,
+        }
+
+    def _setup_stream(self, url, hf_token):
+        return utils.download_byte_stream(url, hf_token)
+
+    def _deserialize_single(
+        self,
+        x: str | FileData | None,
+        save_dir: str | None = None,
+        root_url: str | None = None,
+        hf_token: str | None = None,
+    ) -> str | None:
+        if x is None:
+            return None
+        if isinstance(x, str):
+            file_name = utils.decode_base64_to_file(x, dir=save_dir).name
+        elif isinstance(x, dict):
+            if x.get("is_file"):
+                filepath = x.get("name")
+                assert filepath is not None, f"The 'name' field is missing in {x}"
+                if root_url is not None:
+                    file_name = utils.download_tmp_copy_of_file(
+                        root_url + "file=" + filepath,
+                        hf_token=hf_token,
+                        dir=save_dir,
+                    )
+                else:
+                    file_name = utils.create_tmp_copy_of_file(filepath, dir=save_dir)
+            elif x.get("is_stream"):
+                assert x["name"] and root_url and save_dir
+                if not self.stream or self.stream_name != x["name"]:
+                    self.stream = self._setup_stream(
+                        root_url + "stream/" + x["name"], hf_token=hf_token
+                    )
+                    self.stream_name = x["name"]
+                chunk = next(self.stream)
+                path = Path(save_dir or tempfile.gettempdir()) / secrets.token_hex(20)
+                path.mkdir(parents=True, exist_ok=True)
+                path = path / x.get("orig_name", "output")
+                path.write_bytes(chunk)
+                file_name = str(path)
+            else:
+                data = x.get("data")
+                assert data is not None, f"The 'data' field is missing in {x}"
+                file_name = utils.decode_base64_to_file(data, dir=save_dir).name
+        else:
+            raise ValueError(
+                f"A FileSerializable component can only deserialize a string or a dict, not a {type(x)}: {x}"
+            )
+        return file_name
+
+    def serialize(
+        self,
+        x: str | FileData | None | list[str | FileData | None],
+        load_dir: str | Path = "",
+        allow_links: bool = False,
+    ) -> FileData | None | list[FileData | None]:
+        """
+        Convert from human-friendly version of a file (string filepath) to a
+        serialized representation (base64)
+        Parameters:
+            x: String path to file to serialize
+            load_dir: Path to directory containing x
+            allow_links: Will allow path returns instead of raw file content
+        """
+        if x is None or x == "":
+            return None
+        if isinstance(x, list):
+            return [self._serialize_single(f, load_dir, allow_links) for f in x]
+        else:
+            return self._serialize_single(x, load_dir, allow_links)
+
+    def deserialize(
+        self,
+        x: str | FileData | None | list[str | FileData | None],
+        save_dir: Path | str | None = None,
+        root_url: str | None = None,
+        hf_token: str | None = None,
+    ) -> str | None | list[str | None]:
+        """
+        Convert from serialized representation of a file (base64) to a human-friendly
+        version (string filepath). Optionally, save the file to the directory specified by `save_dir`
+        Parameters:
+            x: Base64 representation of file to deserialize into a string filepath
+            save_dir: Path to directory to save the deserialized file to
+            root_url: If this component is loaded from an external Space, this is the URL of the Space.
+            hf_token: If this component is loaded from an external private Space, this is the access token for the Space
+        """
+        if x is None:
+            return None
+        if isinstance(save_dir, Path):
+            save_dir = str(save_dir)
+        if isinstance(x, list):
+            return [
+                self._deserialize_single(
+                    f, save_dir=save_dir, root_url=root_url, hf_token=hf_token
+                )
+                for f in x
+            ]
+        else:
+            return self._deserialize_single(
+                x, save_dir=save_dir, root_url=root_url, hf_token=hf_token
+            )
+
+
+class VideoSerializable(FileSerializable):
+    def serialized_info(self):
+        return {"type": "string", "description": "filepath or URL to video file"}
+
+    def api_info(self) -> dict[str, dict | bool]:
+        return {"info": serializer_types["FileSerializable"], "serialized_info": True}
+
+    def example_inputs(self) -> dict[str, Any]:
+        return {
+            "raw": {"is_file": False, "data": media_data.BASE64_VIDEO},
+            "serialized": "https://github.com/gradio-app/gradio/raw/main/test/test_files/video_sample.mp4",
+        }
+
+    def serialize(
+        self, x: str | None, load_dir: str | Path = "", allow_links: bool = False
+    ) -> tuple[FileData | None, None]:
+        return (super().serialize(x, load_dir, allow_links), None)  # type: ignore
+
+    def deserialize(
+        self,
+        x: tuple[FileData | None, FileData | None] | None,
+        save_dir: Path | str | None = None,
+        root_url: str | None = None,
+        hf_token: str | None = None,
+    ) -> str | tuple[str | None, str | None] | None:
+        """
+        Convert from serialized representation of a file (base64) to a human-friendly
+        version (string filepath). Optionally, save the file to the directory specified by `save_dir`
+        """
+        if isinstance(x, (tuple, list)):
+            assert len(x) == 2, f"Expected tuple of length 2. Received: {x}"
+            x_as_list = [x[0], x[1]]
+        else:
+            raise ValueError(f"Expected tuple of length 2. Received: {x}")
+        deserialized_file = super().deserialize(x_as_list, save_dir, root_url, hf_token)  # type: ignore
+        if isinstance(deserialized_file, list):
+            return deserialized_file[0]  # ignore subtitles
+
+
+class JSONSerializable(Serializable):
+    def serialized_info(self):
+        return {"type": "string", "description": "filepath to JSON file"}
+
+    def api_info(self) -> dict[str, dict | bool]:
+        return {"info": serializer_types["JSONSerializable"], "serialized_info": True}
+
+    def example_inputs(self) -> dict[str, Any]:
+        return {
+            "raw": {"a": 1, "b": 2},
+            "serialized": None,
+        }
+
+    def serialize(
+        self,
+        x: str | None,
+        load_dir: str | Path = "",
+        allow_links: bool = False,
+    ) -> dict | list | None:
+        """
+        Convert from a a human-friendly version (string path to json file) to a
+        serialized representation (json string)
+        Parameters:
+            x: String path to json file to read to get json string
+            load_dir: Path to directory containing x
+        """
+        if x is None or x == "":
+            return None
+        return utils.file_to_json(Path(load_dir) / x)
+
+    def deserialize(
+        self,
+        x: str | dict | list,
+        save_dir: str | Path | None = None,
+        root_url: str | None = None,
+        hf_token: str | None = None,
+    ) -> str | None:
+        """
+        Convert from serialized representation (json string) to a human-friendly
+        version (string path to json file).  Optionally, save the file to the directory specified by `save_dir`
+        Parameters:
+            x: Json string
+            save_dir: Path to save the deserialized json file to
+            root_url: Ignored
+            hf_token: Ignored
+        """
+        if x is None:
+            return None
+        return utils.dict_or_str_to_json_file(x, dir=save_dir).name
+
+
+class GallerySerializable(Serializable):
+    def serialized_info(self):
+        return {
+            "type": "string",
+            "description": "path to directory with images and a file associating images with captions called captions.json",
+        }
+
+    def api_info(self) -> dict[str, dict | bool]:
+        return {
+            "info": serializer_types["GallerySerializable"],
+            "serialized_info": True,
+        }
+
+    def example_inputs(self) -> dict[str, Any]:
+        return {
+            "raw": [media_data.BASE64_IMAGE] * 2,
+            "serialized": [
+                "https://raw.githubusercontent.com/gradio-app/gradio/main/test/test_files/bus.png",
+            ]
+            * 2,
+        }
+
+    def serialize(
+        self, x: str | None, load_dir: str | Path = "", allow_links: bool = False
+    ) -> list[list[str | None]] | None:
+        if x is None or x == "":
+            return None
+        files = []
+        captions_file = Path(x) / "captions.json"
+        with captions_file.open("r") as captions_json:
+            captions = json.load(captions_json)
+        for file_name, caption in captions.items():
+            img = FileSerializable().serialize(file_name, allow_links=allow_links)
+            files.append([img, caption])
+        return files
+
+    def deserialize(
+        self,
+        x: list[list[str | None]] | None,
+        save_dir: str = "",
+        root_url: str | None = None,
+        hf_token: str | None = None,
+    ) -> None | str:
+        if x is None:
+            return None
+        gallery_path = Path(save_dir) / str(uuid.uuid4())
+        gallery_path.mkdir(exist_ok=True, parents=True)
+        captions = {}
+        for img_data in x:
+            if isinstance(img_data, (list, tuple)):
+                img_data, caption = img_data
+            else:
+                caption = None
+            name = FileSerializable().deserialize(
+                img_data, gallery_path, root_url=root_url, hf_token=hf_token
+            )
+            captions[name] = caption
+            captions_file = gallery_path / "captions.json"
+            with captions_file.open("w") as captions_json:
+                json.dump(captions, captions_json)
+        return os.path.abspath(gallery_path)
+
+
+SERIALIZER_MAPPING = {}
+for cls in Serializable.__subclasses__():
+    SERIALIZER_MAPPING[cls.__name__] = cls
+    for subcls in cls.__subclasses__():
+        SERIALIZER_MAPPING[subcls.__name__] = subcls
+
+SERIALIZER_MAPPING["Serializable"] = SimpleSerializable
+SERIALIZER_MAPPING["File"] = FileSerializable
+SERIALIZER_MAPPING["UploadButton"] = FileSerializable
+
+COMPONENT_MAPPING: dict[str, type] = {
+    "textbox": StringSerializable,
+    "number": NumberSerializable,
+    "slider": NumberSerializable,
+    "checkbox": BooleanSerializable,
+    "checkboxgroup": ListStringSerializable,
+    "radio": StringSerializable,
+    "dropdown": SimpleSerializable,
+    "image": ImgSerializable,
+    "video": FileSerializable,
+    "audio": FileSerializable,
+    "file": FileSerializable,
+    "dataframe": JSONSerializable,
+    "timeseries": JSONSerializable,
+    "state": SimpleSerializable,
+    "button": StringSerializable,
+    "uploadbutton": FileSerializable,
+    "colorpicker": StringSerializable,
+    "label": JSONSerializable,
+    "highlightedtext": JSONSerializable,
+    "json": JSONSerializable,
+    "html": StringSerializable,
+    "gallery": GallerySerializable,
+    "chatbot": JSONSerializable,
+    "model3d": FileSerializable,
+    "plot": JSONSerializable,
+    "barplot": JSONSerializable,
+    "lineplot": JSONSerializable,
+    "scatterplot": JSONSerializable,
+    "markdown": StringSerializable,
+    "code": StringSerializable,
+    "annotatedimage": JSONSerializable,
+}

testbed/gradio-app__gradio/client/python/gradio_client/templates/discord_chat.py

@@ -0,0 +1,193 @@
+import asyncio
+import os
+import threading
+from threading import Event
+from typing import Optional
+
+import discord
+import gradio as gr
+from discord import Permissions
+from discord.ext import commands
+from discord.utils import oauth_url
+
+import gradio_client as grc
+from gradio_client.utils import QueueError
+
+event = Event()
+
+DISCORD_TOKEN = os.getenv("DISCORD_TOKEN")
+
+
+async def wait(job):
+    while not job.done():
+        await asyncio.sleep(0.2)
+
+
+def get_client(session: Optional[str] = None) -> grc.Client:
+    client = grc.Client("<<app-src>>", hf_token=os.getenv("HF_TOKEN"))
+    if session:
+        client.session_hash = session
+    return client
+
+
+def truncate_response(response: str) -> str:
+    ending = "...\nTruncating response to 2000 characters due to discord api limits."
+    if len(response) > 2000:
+        return response[: 2000 - len(ending)] + ending
+    else:
+        return response
+
+
+intents = discord.Intents.default()
+intents.message_content = True
+bot = commands.Bot(command_prefix="/", intents=intents)
+
+
+@bot.event
+async def on_ready():
+    print(f"Logged in as {bot.user} (ID: {bot.user.id})")
+    synced = await bot.tree.sync()
+    print(f"Synced commands: {', '.join([s.name for s in synced])}.")
+    event.set()
+    print("------")
+
+
+thread_to_client = {}
+thread_to_user = {}
+
+
+@bot.hybrid_command(
+    name="<<command-name>>",
+    description="Enter some text to chat with the bot! Like this: /<<command-name>> Hello, how are you?",
+)
+async def chat(ctx, prompt: str):
+    if ctx.author.id == bot.user.id:
+        return
+    try:
+        message = await ctx.send("Creating thread...")
+
+        thread = await message.create_thread(name=prompt)
+        loop = asyncio.get_running_loop()
+        client = await loop.run_in_executor(None, get_client, None)
+        job = client.submit(prompt, api_name="/<<api-name>>")
+        await wait(job)
+
+        try:
+            job.result()
+            response = job.outputs()[-1]
+            await thread.send(truncate_response(response))
+            thread_to_client[thread.id] = client
+            thread_to_user[thread.id] = ctx.author.id
+        except QueueError:
+            await thread.send(
+                "The gradio space powering this bot is really busy! Please try again later!"
+            )
+
+    except Exception as e:
+        print(f"{e}")
+
+
+async def continue_chat(message):
+    """Continues a given conversation based on chathistory"""
+    try:
+        client = thread_to_client[message.channel.id]
+        prompt = message.content
+        job = client.submit(prompt, api_name="/<<api-name>>")
+        await wait(job)
+        try:
+            job.result()
+            response = job.outputs()[-1]
+            await message.reply(truncate_response(response))
+        except QueueError:
+            await message.reply(
+                "The gradio space powering this bot is really busy! Please try again later!"
+            )
+
+    except Exception as e:
+        print(f"Error: {e}")
+
+
+@bot.event
+async def on_message(message):
+    """Continue the chat"""
+    try:
+        if not message.author.bot:
+            if message.channel.id in thread_to_user:
+                if thread_to_user[message.channel.id] == message.author.id:
+                    await continue_chat(message)
+            else:
+                await bot.process_commands(message)
+
+    except Exception as e:
+        print(f"Error: {e}")
+
+
+# running in thread
+def run_bot():
+    if not DISCORD_TOKEN:
+        print("DISCORD_TOKEN NOT SET")
+        event.set()
+    else:
+        bot.run(DISCORD_TOKEN)
+
+
+threading.Thread(target=run_bot).start()
+
+event.wait()
+
+if not DISCORD_TOKEN:
+    welcome_message = """
+
+    ## You have not specified a DISCORD_TOKEN, which means you have not created a bot account. Please follow these steps:
+
+    ### 1. Go to https://discord.com/developers/applications and click 'New Application'
+    
+    ### 2. Give your bot a name 🤖
+
+    ![](https://gradio-builds.s3.amazonaws.com/demo-files/discordbots/BotName.png)
+    
+    ## 3. In Settings > Bot, click the 'Reset Token' button to get a new token. Write it down and keep it safe 🔐
+    
+    ![](https://gradio-builds.s3.amazonaws.com/demo-files/discordbots/ResetToken.png)
+    
+    ## 4. Optionally make the bot public if you want anyone to be able to add it to their servers
+    
+    ## 5. Scroll down and enable 'Message Content Intent' under 'Priviledged Gateway Intents'
+    
+    ![](https://gradio-builds.s3.amazonaws.com/demo-files/discordbots/MessageContentIntent.png)
+
+    ## 6. Save your changes!
+
+    ## 7. The token from step 3 is the DISCORD_TOKEN. Rerun the deploy_discord command, e.g client.deploy_discord(discord_bot_token=DISCORD_TOKEN, ...), or add the token as a space secret manually.
+"""
+else:
+    permissions = Permissions(326417525824)
+    url = oauth_url(bot.user.id, permissions=permissions)
+    welcome_message = f"""
+    ## Add this bot to your server by clicking this link: 
+    
+    {url}
+
+    ## How to use it?
+
+    The bot can be triggered via `/<<command-name>>` followed by your text prompt.
+    
+    This will create a thread with the bot's response to your text prompt.
+    You can reply in the thread (without `/<<command-name>>`) to continue the conversation.
+    In the thread, the bot will only reply to the original author of the command.
+
+    ⚠️ Note ⚠️: Please make sure this bot's command does have the same name as another command in your server.
+    
+    ⚠️ Note ⚠️: Bot commands do not work in DMs with the bot as of now.
+    """
+
+
+with gr.Blocks() as demo:
+    gr.Markdown(
+        f"""
+    # Discord bot of <<app-src>>
+    {welcome_message}
+    """
+    )
+
+demo.launch()

testbed/gradio-app__gradio/client/python/gradio_client/types.json

@@ -0,0 +1,199 @@
+{
+	"SimpleSerializable": {
+		"type": {},
+		"description": "any valid value"
+	},
+	"StringSerializable": {
+		"type": "string"
+	},
+	"ListStringSerializable": {
+		"type": "array",
+		"items": {
+			"type": "string"
+		}
+	},
+	"BooleanSerializable": {
+		"type": "boolean"
+	},
+	"NumberSerializable": {
+		"type": "number"
+	},
+	"ImgSerializable": {
+		"type": "string",
+		"description": "base64 representation of an image"
+	},
+	"FileSerializable": {
+		"oneOf": [
+			{
+				"type": "string",
+				"description": "filepath or URL to file"
+			},
+			{
+				"type": "object",
+				"properties": {
+					"name": { "type": "string", "description": "name of file" },
+					"data": {
+						"type": "string",
+						"description": "base64 representation of file"
+					},
+					"size": {
+						"type": "integer",
+						"description": "size of image in bytes"
+					},
+					"is_file": {
+						"type": "boolean",
+						"description": "true if the file has been uploaded to the server"
+					},
+					"orig_name": {
+						"type": "string",
+						"description": "original name of the file"
+					}
+				},
+				"required": ["name", "data"]
+			},
+			{
+				"type": "array",
+				"items": {
+					"anyOf": [
+						{
+							"type": "string",
+							"description": "filepath or URL to file"
+						},
+						{
+							"type": "object",
+							"properties": {
+								"name": { "type": "string", "description": "name of file" },
+								"data": {
+									"type": "string",
+									"description": "base64 representation of file"
+								},
+								"size": {
+									"type": "integer",
+									"description": "size of image in bytes"
+								},
+								"is_file": {
+									"type": "boolean",
+									"description": "true if the file has been uploaded to the server"
+								},
+								"orig_name": {
+									"type": "string",
+									"description": "original name of the file"
+								}
+							},
+							"required": ["name", "data"]
+						}
+					]
+				}
+			}
+		]
+	},
+	"SingleFileSerializable": {
+		"oneOf": [
+			{
+				"type": "string",
+				"description": "filepath or URL to file"
+			},
+			{
+				"type": "object",
+				"properties": {
+					"name": { "type": "string", "description": "name of file" },
+					"data": {
+						"type": "string",
+						"description": "base64 representation of file"
+					},
+					"size": {
+						"type": "integer",
+						"description": "size of image in bytes"
+					},
+					"is_file": {
+						"type": "boolean",
+						"description": "true if the file has been uploaded to the server"
+					},
+					"orig_name": {
+						"type": "string",
+						"description": "original name of the file"
+					}
+				},
+				"required": ["name", "data"]
+			}
+		]
+	},
+	"MultipleFileSerializable": {
+		"type": "array",
+		"items": {
+			"anyOf": [
+				{
+					"type": "string",
+					"description": "filepath or URL to file"
+				},
+				{
+					"type": "object",
+					"properties": {
+						"name": { "type": "string", "description": "name of file" },
+						"data": {
+							"type": "string",
+							"description": "base64 representation of file"
+						},
+						"size": {
+							"type": "integer",
+							"description": "size of image in bytes"
+						},
+						"is_file": {
+							"type": "boolean",
+							"description": "true if the file has been uploaded to the server"
+						},
+						"orig_name": {
+							"type": "string",
+							"description": "original name of the file"
+						}
+					},
+					"required": ["name", "data"]
+				}
+			]
+		}
+	},
+	"JSONSerializable": {
+		"type": {},
+		"description": "any valid json"
+	},
+	"GallerySerializable": {
+		"type": "array",
+		"items": {
+			"type": "array",
+			"items": false,
+			"maxSize": 2,
+			"minSize": 2,
+			"prefixItems": [
+				{
+					"type": "object",
+					"properties": {
+						"name": { "type": "string", "description": "name of file" },
+						"data": {
+							"type": "string",
+							"description": "base64 representation of file"
+						},
+						"size": {
+							"type": "integer",
+							"description": "size of image in bytes"
+						},
+						"is_file": {
+							"type": "boolean",
+							"description": "true if the file has been uploaded to the server"
+						},
+						"orig_name": {
+							"type": "string",
+							"description": "original name of the file"
+						}
+					},
+					"required": ["name", "data"]
+				},
+				{
+					"oneOf": [
+						{ "type": "string", "description": "caption of image" },
+						{ "type": "null" }
+					]
+				}
+			]
+		}
+	}
+}

testbed/gradio-app__gradio/client/python/gradio_client/utils.py

@@ -0,0 +1,598 @@
+from __future__ import annotations
+
+import asyncio
+import base64
+import json
+import mimetypes
+import os
+import pkgutil
+import secrets
+import shutil
+import tempfile
+import warnings
+from concurrent.futures import CancelledError
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from pathlib import Path
+from threading import Lock
+from typing import Any, Callable, Optional
+
+import fsspec.asyn
+import httpx
+import huggingface_hub
+import requests
+from huggingface_hub import SpaceStage
+from websockets.legacy.protocol import WebSocketCommonProtocol
+
+API_URL = "api/predict/"
+WS_URL = "queue/join"
+UPLOAD_URL = "upload"
+CONFIG_URL = "config"
+API_INFO_URL = "info"
+RAW_API_INFO_URL = "info?serialize=False"
+SPACE_FETCHER_URL = "https://gradio-space-api-fetcher-v2.hf.space/api"
+RESET_URL = "reset"
+SPACE_URL = "https://hf.space/{}"
+
+SKIP_COMPONENTS = {
+    "state",
+    "row",
+    "column",
+    "tabs",
+    "tab",
+    "tabitem",
+    "box",
+    "form",
+    "accordion",
+    "group",
+    "interpretation",
+    "dataset",
+}
+STATE_COMPONENT = "state"
+INVALID_RUNTIME = [
+    SpaceStage.NO_APP_FILE,
+    SpaceStage.CONFIG_ERROR,
+    SpaceStage.BUILD_ERROR,
+    SpaceStage.RUNTIME_ERROR,
+    SpaceStage.PAUSED,
+]
+
+
+def get_package_version() -> str:
+    try:
+        package_json_data = (
+            pkgutil.get_data(__name__, "package.json").decode("utf-8").strip()  # type: ignore
+        )
+        package_data = json.loads(package_json_data)
+        version = package_data.get("version", "")
+        return version
+    except Exception:
+        return ""
+
+
+__version__ = get_package_version()
+
+
+class TooManyRequestsError(Exception):
+    """Raised when the API returns a 429 status code."""
+
+    pass
+
+
+class QueueError(Exception):
+    """Raised when the queue is full or there is an issue adding a job to the queue."""
+
+    pass
+
+
+class InvalidAPIEndpointError(Exception):
+    """Raised when the API endpoint is invalid."""
+
+    pass
+
+
+class SpaceDuplicationError(Exception):
+    """Raised when something goes wrong with a Space Duplication."""
+
+    pass
+
+
+class Status(Enum):
+    """Status codes presented to client users."""
+
+    STARTING = "STARTING"
+    JOINING_QUEUE = "JOINING_QUEUE"
+    QUEUE_FULL = "QUEUE_FULL"
+    IN_QUEUE = "IN_QUEUE"
+    SENDING_DATA = "SENDING_DATA"
+    PROCESSING = "PROCESSING"
+    ITERATING = "ITERATING"
+    PROGRESS = "PROGRESS"
+    FINISHED = "FINISHED"
+    CANCELLED = "CANCELLED"
+
+    @staticmethod
+    def ordering(status: Status) -> int:
+        """Order of messages. Helpful for testing."""
+        order = [
+            Status.STARTING,
+            Status.JOINING_QUEUE,
+            Status.QUEUE_FULL,
+            Status.IN_QUEUE,
+            Status.SENDING_DATA,
+            Status.PROCESSING,
+            Status.PROGRESS,
+            Status.ITERATING,
+            Status.FINISHED,
+            Status.CANCELLED,
+        ]
+        return order.index(status)
+
+    def __lt__(self, other: Status):
+        return self.ordering(self) < self.ordering(other)
+
+    @staticmethod
+    def msg_to_status(msg: str) -> Status:
+        """Map the raw message from the backend to the status code presented to users."""
+        return {
+            "send_hash": Status.JOINING_QUEUE,
+            "queue_full": Status.QUEUE_FULL,
+            "estimation": Status.IN_QUEUE,
+            "send_data": Status.SENDING_DATA,
+            "process_starts": Status.PROCESSING,
+            "process_generating": Status.ITERATING,
+            "process_completed": Status.FINISHED,
+            "progress": Status.PROGRESS,
+        }[msg]
+
+
+@dataclass
+class ProgressUnit:
+    index: Optional[int]
+    length: Optional[int]
+    unit: Optional[str]
+    progress: Optional[float]
+    desc: Optional[str]
+
+    @classmethod
+    def from_ws_msg(cls, data: list[dict]) -> list[ProgressUnit]:
+        return [
+            cls(
+                index=d.get("index"),
+                length=d.get("length"),
+                unit=d.get("unit"),
+                progress=d.get("progress"),
+                desc=d.get("desc"),
+            )
+            for d in data
+        ]
+
+
+@dataclass
+class StatusUpdate:
+    """Update message sent from the worker thread to the Job on the main thread."""
+
+    code: Status
+    rank: int | None
+    queue_size: int | None
+    eta: float | None
+    success: bool | None
+    time: datetime | None
+    progress_data: list[ProgressUnit] | None
+
+
+def create_initial_status_update():
+    return StatusUpdate(
+        code=Status.STARTING,
+        rank=None,
+        queue_size=None,
+        eta=None,
+        success=None,
+        time=datetime.now(),
+        progress_data=None,
+    )
+
+
+@dataclass
+class JobStatus:
+    """The job status.
+
+    Keeps track of the latest status update and intermediate outputs (not yet implements).
+    """
+
+    latest_status: StatusUpdate = field(default_factory=create_initial_status_update)
+    outputs: list[Any] = field(default_factory=list)
+
+
+@dataclass
+class Communicator:
+    """Helper class to help communicate between the worker thread and main thread."""
+
+    lock: Lock
+    job: JobStatus
+    prediction_processor: Callable[..., tuple]
+    reset_url: str
+    should_cancel: bool = False
+
+
+########################
+# Network utils
+########################
+
+
+def is_http_url_like(possible_url: str) -> bool:
+    """
+    Check if the given string looks like an HTTP(S) URL.
+    """
+    return possible_url.startswith(("http://", "https://"))
+
+
+def probe_url(possible_url: str) -> bool:
+    """
+    Probe the given URL to see if it responds with a 200 status code (to HEAD, then to GET).
+    """
+    headers = {"User-Agent": "gradio (https://gradio.app/; team@gradio.app)"}
+    try:
+        with requests.session() as sess:
+            head_request = sess.head(possible_url, headers=headers)
+            if head_request.status_code == 405:
+                return sess.get(possible_url, headers=headers).ok
+            return head_request.ok
+    except Exception:
+        return False
+
+
+def is_valid_url(possible_url: str) -> bool:
+    """
+    Check if the given string is a valid URL.
+    """
+    warnings.warn(
+        "is_valid_url should not be used. "
+        "Use is_http_url_like() and probe_url(), as suitable, instead.",
+    )
+    return is_http_url_like(possible_url) and probe_url(possible_url)
+
+
+async def get_pred_from_ws(
+    websocket: WebSocketCommonProtocol,
+    data: str,
+    hash_data: str,
+    helper: Communicator | None = None,
+) -> dict[str, Any]:
+    completed = False
+    resp = {}
+    while not completed:
+        # Receive message in the background so that we can
+        # cancel even while running a long pred
+        task = asyncio.create_task(websocket.recv())
+        while not task.done():
+            if helper:
+                with helper.lock:
+                    if helper.should_cancel:
+                        # Need to reset the iterator state since the client
+                        # will not reset the session
+                        async with httpx.AsyncClient() as http:
+                            reset = http.post(
+                                helper.reset_url, json=json.loads(hash_data)
+                            )
+                            # Retrieve cancel exception from task
+                            # otherwise will get nasty warning in console
+                            task.cancel()
+                            await asyncio.gather(task, reset, return_exceptions=True)
+                        raise CancelledError()
+            # Need to suspend this coroutine so that task actually runs
+            await asyncio.sleep(0.01)
+        msg = task.result()
+        resp = json.loads(msg)
+        if helper:
+            with helper.lock:
+                has_progress = "progress_data" in resp
+                status_update = StatusUpdate(
+                    code=Status.msg_to_status(resp["msg"]),
+                    queue_size=resp.get("queue_size"),
+                    rank=resp.get("rank", None),
+                    success=resp.get("success"),
+                    time=datetime.now(),
+                    eta=resp.get("rank_eta"),
+                    progress_data=ProgressUnit.from_ws_msg(resp["progress_data"])
+                    if has_progress
+                    else None,
+                )
+                output = resp.get("output", {}).get("data", [])
+                if output and status_update.code != Status.FINISHED:
+                    try:
+                        result = helper.prediction_processor(*output)
+                    except Exception as e:
+                        result = [e]
+                    helper.job.outputs.append(result)
+                helper.job.latest_status = status_update
+        if resp["msg"] == "queue_full":
+            raise QueueError("Queue is full! Please try again.")
+        if resp["msg"] == "send_hash":
+            await websocket.send(hash_data)
+        elif resp["msg"] == "send_data":
+            await websocket.send(data)
+        completed = resp["msg"] == "process_completed"
+    return resp["output"]
+
+
+########################
+# Data processing utils
+########################
+
+
+def download_tmp_copy_of_file(
+    url_path: str, hf_token: str | None = None, dir: str | None = None
+) -> str:
+    if dir is not None:
+        os.makedirs(dir, exist_ok=True)
+    headers = {"Authorization": "Bearer " + hf_token} if hf_token else {}
+    directory = Path(dir or tempfile.gettempdir()) / secrets.token_hex(20)
+    directory.mkdir(exist_ok=True, parents=True)
+    file_path = directory / Path(url_path).name
+
+    with requests.get(url_path, headers=headers, stream=True) as r:
+        r.raise_for_status()
+        with open(file_path, "wb") as f:
+            shutil.copyfileobj(r.raw, f)
+    return str(file_path.resolve())
+
+
+def create_tmp_copy_of_file(file_path: str, dir: str | None = None) -> str:
+    directory = Path(dir or tempfile.gettempdir()) / secrets.token_hex(20)
+    directory.mkdir(exist_ok=True, parents=True)
+    dest = directory / Path(file_path).name
+    shutil.copy2(file_path, dest)
+    return str(dest.resolve())
+
+
+def get_mimetype(filename: str) -> str | None:
+    if filename.endswith(".vtt"):
+        return "text/vtt"
+    mimetype = mimetypes.guess_type(filename)[0]
+    if mimetype is not None:
+        mimetype = mimetype.replace("x-wav", "wav").replace("x-flac", "flac")
+    return mimetype
+
+
+def get_extension(encoding: str) -> str | None:
+    encoding = encoding.replace("audio/wav", "audio/x-wav")
+    type = mimetypes.guess_type(encoding)[0]
+    if type == "audio/flac":  # flac is not supported by mimetypes
+        return "flac"
+    elif type is None:
+        return None
+    extension = mimetypes.guess_extension(type)
+    if extension is not None and extension.startswith("."):
+        extension = extension[1:]
+    return extension
+
+
+def encode_file_to_base64(f: str | Path):
+    with open(f, "rb") as file:
+        encoded_string = base64.b64encode(file.read())
+        base64_str = str(encoded_string, "utf-8")
+        mimetype = get_mimetype(str(f))
+        return (
+            "data:"
+            + (mimetype if mimetype is not None else "")
+            + ";base64,"
+            + base64_str
+        )
+
+
+def encode_url_to_base64(url: str):
+    resp = requests.get(url)
+    resp.raise_for_status()
+    encoded_string = base64.b64encode(resp.content)
+    base64_str = str(encoded_string, "utf-8")
+    mimetype = get_mimetype(url)
+    return (
+        "data:" + (mimetype if mimetype is not None else "") + ";base64," + base64_str
+    )
+
+
+def encode_url_or_file_to_base64(path: str | Path):
+    path = str(path)
+    if is_http_url_like(path):
+        return encode_url_to_base64(path)
+    return encode_file_to_base64(path)
+
+
+def download_byte_stream(url: str, hf_token=None):
+    arr = bytearray()
+    headers = {"Authorization": "Bearer " + hf_token} if hf_token else {}
+    with httpx.stream("GET", url, headers=headers) as r:
+        for data in r.iter_bytes():
+            arr += data
+            yield data
+    yield arr
+
+
+def decode_base64_to_binary(encoding: str) -> tuple[bytes, str | None]:
+    extension = get_extension(encoding)
+    data = encoding.rsplit(",", 1)[-1]
+    return base64.b64decode(data), extension
+
+
+def strip_invalid_filename_characters(filename: str, max_bytes: int = 200) -> str:
+    """Strips invalid characters from a filename and ensures that the file_length is less than `max_bytes` bytes."""
+    filename = "".join([char for char in filename if char.isalnum() or char in "._- "])
+    filename_len = len(filename.encode())
+    if filename_len > max_bytes:
+        while filename_len > max_bytes:
+            if len(filename) == 0:
+                break
+            filename = filename[:-1]
+            filename_len = len(filename.encode())
+    return filename
+
+
+def sanitize_parameter_names(original_name: str) -> str:
+    """Cleans up a Python parameter name to make the API info more readable."""
+    return (
+        "".join([char for char in original_name if char.isalnum() or char in " _"])
+        .replace(" ", "_")
+        .lower()
+    )
+
+
+def decode_base64_to_file(
+    encoding: str,
+    file_path: str | None = None,
+    dir: str | Path | None = None,
+    prefix: str | None = None,
+):
+    directory = Path(dir or tempfile.gettempdir()) / secrets.token_hex(20)
+    directory.mkdir(exist_ok=True, parents=True)
+    data, extension = decode_base64_to_binary(encoding)
+    if file_path is not None and prefix is None:
+        filename = Path(file_path).name
+        prefix = filename
+        if "." in filename:
+            prefix = filename[0 : filename.index(".")]
+            extension = filename[filename.index(".") + 1 :]
+
+    if prefix is not None:
+        prefix = strip_invalid_filename_characters(prefix)
+
+    if extension is None:
+        file_obj = tempfile.NamedTemporaryFile(
+            delete=False, prefix=prefix, dir=directory
+        )
+    else:
+        file_obj = tempfile.NamedTemporaryFile(
+            delete=False,
+            prefix=prefix,
+            suffix="." + extension,
+            dir=directory,
+        )
+    file_obj.write(data)
+    file_obj.flush()
+    return file_obj
+
+
+def dict_or_str_to_json_file(jsn: str | dict | list, dir: str | Path | None = None):
+    if dir is not None:
+        os.makedirs(dir, exist_ok=True)
+
+    file_obj = tempfile.NamedTemporaryFile(
+        delete=False, suffix=".json", dir=dir, mode="w+"
+    )
+    if isinstance(jsn, str):
+        jsn = json.loads(jsn)
+    json.dump(jsn, file_obj)
+    file_obj.flush()
+    return file_obj
+
+
+def file_to_json(file_path: str | Path) -> dict | list:
+    with open(file_path) as f:
+        return json.load(f)
+
+
+###########################
+# HuggingFace Hub API Utils
+###########################
+def set_space_timeout(
+    space_id: str,
+    hf_token: str | None = None,
+    timeout_in_seconds: int = 300,
+):
+    headers = huggingface_hub.utils.build_hf_headers(
+        token=hf_token,
+        library_name="gradio_client",
+        library_version=__version__,
+    )
+    req = requests.post(
+        f"https://huggingface.co/api/spaces/{space_id}/sleeptime",
+        json={"seconds": timeout_in_seconds},
+        headers=headers,
+    )
+    try:
+        huggingface_hub.utils.hf_raise_for_status(req)
+    except huggingface_hub.utils.HfHubHTTPError as err:
+        raise SpaceDuplicationError(
+            f"Could not set sleep timeout on duplicated Space. Please visit {SPACE_URL.format(space_id)} "
+            "to set a timeout manually to reduce billing charges."
+        ) from err
+
+
+########################
+# Misc utils
+########################
+
+
+def synchronize_async(func: Callable, *args, **kwargs) -> Any:
+    """
+    Runs async functions in sync scopes. Can be used in any scope.
+
+    Example:
+        if inspect.iscoroutinefunction(block_fn.fn):
+            predictions = utils.synchronize_async(block_fn.fn, *processed_input)
+
+    Args:
+        func:
+        *args:
+        **kwargs:
+    """
+    return fsspec.asyn.sync(fsspec.asyn.get_loop(), func, *args, **kwargs)  # type: ignore
+
+
+class APIInfoParseError(ValueError):
+    pass
+
+
+def get_type(schema: dict):
+    if "type" in schema:
+        return schema["type"]
+    elif schema.get("oneOf"):
+        return "oneOf"
+    elif schema.get("anyOf"):
+        return "anyOf"
+    else:
+        raise APIInfoParseError(f"Cannot parse type for {schema}")
+
+
+def json_schema_to_python_type(schema: Any) -> str:
+    """Convert the json schema into a python type hint"""
+    type_ = get_type(schema)
+    if type_ == {}:
+        if "json" in schema["description"]:
+            return "Dict[Any, Any]"
+        else:
+            return "Any"
+    elif type_ == "null":
+        return "None"
+    elif type_ == "integer":
+        return "int"
+    elif type_ == "string":
+        return "str"
+    elif type_ == "boolean":
+        return "bool"
+    elif type_ == "number":
+        return "int | float"
+    elif type_ == "array":
+        items = schema.get("items")
+        if "prefixItems" in items:
+            elements = ", ".join(
+                [json_schema_to_python_type(i) for i in items["prefixItems"]]
+            )
+            return f"Tuple[{elements}]"
+        else:
+            elements = json_schema_to_python_type(items)
+            return f"List[{elements}]"
+    elif type_ == "object":
+        des = ", ".join(
+            [
+                f"{n}: {json_schema_to_python_type(v)} ({v.get('description')})"
+                for n, v in schema["properties"].items()
+            ]
+        )
+        return f"Dict({des})"
+    elif type_ in ["oneOf", "anyOf"]:
+        desc = " | ".join([json_schema_to_python_type(i) for i in schema[type_]])
+        return desc
+    else:
+        raise APIInfoParseError(f"Cannot parse schema {schema}")

testbed/gradio-app__gradio/client/python/pyproject.toml

@@ -0,0 +1,70 @@
+[build-system]
+requires = ["hatchling", "hatch-requirements-txt", "hatch-fancy-pypi-readme>=22.5.0"]
+build-backend = "hatchling.build"
+
+[project]
+name = "gradio_client"
+dynamic = ["version", "dependencies", "readme"]
+description = "Python library for easily interacting with trained machine learning models"
+license = "Apache-2.0"
+requires-python = ">=3.8"
+authors = [
+  { name = "Abubakar Abid", email = "team@gradio.app" },
+  { name = "Ali Abid", email = "team@gradio.app" },
+  { name = "Ali Abdalla", email = "team@gradio.app" },
+  { name = "Dawood Khan", email = "team@gradio.app" },
+  { name = "Ahsen Khaliq", email = "team@gradio.app" },
+  { name = "Pete Allen", email = "team@gradio.app" },
+  { name = "Freddy Boulton", email = "team@gradio.app" },
+]
+keywords = ["machine learning", "client", "API"]
+
+classifiers = [
+  'Development Status :: 4 - Beta',
+  'License :: OSI Approved :: Apache Software License',
+  'Operating System :: OS Independent',
+  'Programming Language :: Python :: 3',
+  'Programming Language :: Python :: 3 :: Only',
+  'Programming Language :: Python :: 3.8',
+  'Programming Language :: Python :: 3.9',
+  'Programming Language :: Python :: 3.10',
+  'Programming Language :: Python :: 3.11',
+  'Topic :: Scientific/Engineering',
+  'Topic :: Scientific/Engineering :: Artificial Intelligence',
+  'Topic :: Software Development :: User Interfaces',
+]
+
+[project.urls]
+Homepage = "https://github.com/gradio-app/gradio"
+
+[tool.hatch.version]
+path = "gradio_client/package.json"
+pattern = ".*\"version\":\\s*\"(?P<version>[^\"]+)\""
+
+[tool.hatch.metadata.hooks.requirements_txt]
+filename = "requirements.txt"
+
+[tool.hatch.metadata.hooks.fancy-pypi-readme]
+content-type = "text/markdown"
+fragments = [
+  { path = "README.md" },
+]
+
+[tool.hatch.build.targets.sdist]
+include = [
+  "/gradio_client",
+  "/README.md",
+  "/requirements.txt",
+]
+
+[tool.ruff]
+extend = "../../pyproject.toml"
+
+[tool.ruff.isort]
+known-first-party = [
+  "gradio_client"
+]
+
+[tool.pytest.ini_options]
+GRADIO_ANALYTICS_ENABLED = "False"
+HF_HUB_DISABLE_TELEMETRY =  "1"

testbed/gradio-app__gradio/client/python/requirements.txt

@@ -0,0 +1,7 @@
+fsspec
+httpx
+huggingface_hub>=0.13.0
+packaging
+requests~=2.0
+typing_extensions~=4.0
+websockets>=10.0,<12.0

testbed/gradio-app__gradio/client/python/scripts/build_pypi.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+set -e
+
+cd "$(dirname ${0})/.."
+
+python3 -m pip install build
+rm -rf dist/*
+rm -rf build/*
+python3 -m build

testbed/gradio-app__gradio/client/python/scripts/check_pypi.py

@@ -0,0 +1,17 @@
+import json
+import sys
+import urllib.request
+from pathlib import Path
+
+version_file = Path(__file__).parent.parent / "gradio_client" / "package.json"
+with version_file.open() as f:
+    version = json.load(f)["version"]
+
+with urllib.request.urlopen("https://pypi.org/pypi/gradio_client/json") as url:
+    releases = json.load(url)["releases"]
+
+if version in releases:
+    print(f"Version {version} already exists on PyPI")
+    sys.exit(1)
+else:
+    print(f"Version {version} does not exist on PyPI")