Upload folder using huggingface_hub

6.0.0-dev.6/plot/Index.svelte

@@ -0,0 +1,60 @@
+<script context="module" lang="ts">
+	export { default as BasePlot } from "./shared/Plot.svelte";
+</script>
+
+<script lang="ts">
+	import { Gradio } from "@gradio/utils";
+	import Plot from "./shared/Plot.svelte";
+
+	import {
+		Block,
+		BlockLabel,
+		FullscreenButton,
+		IconButtonWrapper
+	} from "@gradio/atoms";
+	import { Plot as PlotIcon } from "@gradio/icons";
+
+	import { StatusTracker } from "@gradio/statustracker";
+	import type { PlotProps, PlotEvents } from "./types.ts";
+
+	let props = $props();
+	const gradio = new Gradio<PlotEvents, PlotProps>(props);
+
+	let fullscreen = $state(false);
+</script>
+
+<Block
+	padding={false}
+	elem_id={gradio.shared.elem_id}
+	elem_classes={gradio.shared.elem_classes}
+	visible={gradio.shared.visible}
+	container={gradio.shared.container}
+	scale={gradio.shared.scale}
+	min_width={gradio.shared.min_width}
+	allow_overflow={false}
+	bind:fullscreen
+>
+	<BlockLabel
+		show_label={gradio.shared.show_label}
+		label={gradio.shared.label || gradio.i18n("plot.plot")}
+		Icon={PlotIcon}
+	/>
+	{#if gradio.props.show_fullscreen_button}
+		<IconButtonWrapper>
+			<FullscreenButton
+				{fullscreen}
+				on:fullscreen={({ detail }) => {
+					fullscreen = detail;
+				}}
+			/>
+		</IconButtonWrapper>
+	{/if}
+	<StatusTracker
+		autoscroll={gradio.shared.autoscroll}
+		i18n={gradio.i18n}
+		{...gradio.shared.loading_status}
+		on:clear_status={() =>
+			gradio.dispatch("clear_status", gradio.shared.loading_status)}
+	/>
+	<Plot {gradio} />
+</Block>

6.0.0-dev.6/plot/package.json

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

6.0.0-dev.6/plot/shared/Plot.svelte

@@ -0,0 +1,72 @@
+<script lang="ts">
+	//@ts-nocheck
+	import { Plot as PlotIcon } from "@gradio/icons";
+	import { Empty } from "@gradio/atoms";
+	import type { Gradio } from "@gradio/utils";
+	import type { PlotEvents, PlotProps } from "../types";
+	import { untrack } from "svelte";
+
+	let { gradio }: { gradio: Gradio<PlotEvents, PlotProps> } = $props();
+
+	let PlotComponent: any = $state(null);
+	let loaded_plotly_css = $state(false);
+	let key = $state(0);
+
+	const plotTypeMapping = {
+		plotly: () => import("./plot_types/PlotlyPlot.svelte"),
+		bokeh: () => import("./plot_types/BokehPlot.svelte"),
+		matplotlib: () => import("./plot_types/MatplotlibPlot.svelte"),
+		altair: () => import("./plot_types/AltairPlot.svelte")
+	};
+
+	let loadedPlotTypeMapping = {};
+
+	const is_browser = typeof window !== "undefined";
+
+	let value = $derived(gradio.props.value);
+	let _type = $state(null);
+
+	$effect(() => {
+		console.log("Plot value changed:", value);
+		let type = value?.type;
+		untrack(() => {
+			key = key + 1;
+			if (type !== _type) {
+				PlotComponent = null;
+			}
+			if (type && type in plotTypeMapping && is_browser) {
+				if (loadedPlotTypeMapping[type]) {
+					PlotComponent = loadedPlotTypeMapping[type];
+				} else {
+					plotTypeMapping[type]().then((module) => {
+						PlotComponent = module.default;
+						loadedPlotTypeMapping[type] = PlotComponent;
+					});
+				}
+			}
+			_type = type;
+		});
+		gradio.dispatch("change");
+	});
+</script>
+
+{#if gradio.props.value && PlotComponent}
+	{#key key}
+		<PlotComponent
+			value={gradio.props.value}
+			colors={[]}
+			theme_mode={gradio.props.theme_mode}
+			show_label={gradio.shared.show_label}
+			caption={gradio.props.caption}
+			bokeh_version={gradio.props.bokeh_version}
+			show_actions_button={gradio.props.show_actions_button}
+			{gradio}
+			_selectable={gradio.props._selectable}
+			x_lim={gradio.props.x_lim}
+			bind:loaded_plotly_css
+			on:select
+		/>
+	{/key}
+{:else}
+	<Empty unpadded_box={true} size="large"><PlotIcon /></Empty>
+{/if}

6.0.0-dev.6/plot/shared/plot_types/AltairPlot.svelte

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

6.0.0-dev.6/plot/shared/plot_types/BokehPlot.svelte

@@ -0,0 +1,89 @@
+<script lang="ts">
+	//@ts-nocheck
+	import { onDestroy } from "svelte";
+
+	export let value;
+	export let bokeh_version: string | null;
+	const div_id = `bokehDiv-${Math.random().toString(5).substring(2)}`;
+	$: plot = value?.plot;
+
+	async function embed_bokeh(_plot: Record<string, any>): void {
+		if (document) {
+			if (document.getElementById(div_id)) {
+				document.getElementById(div_id).innerHTML = "";
+			}
+		}
+		if (window.Bokeh) {
+			load_bokeh();
+			let plotObj = JSON.parse(_plot);
+			await window.Bokeh.embed.embed_item(plotObj, div_id);
+		}
+	}
+
+	$: loaded && embed_bokeh(plot);
+
+	const main_src = `https://cdn.bokeh.org/bokeh/release/bokeh-${bokeh_version}.min.js`;
+
+	const plugins_src = [
+		`https://cdn.pydata.org/bokeh/release/bokeh-widgets-${bokeh_version}.min.js`,
+		`https://cdn.pydata.org/bokeh/release/bokeh-tables-${bokeh_version}.min.js`,
+		`https://cdn.pydata.org/bokeh/release/bokeh-gl-${bokeh_version}.min.js`,
+		`https://cdn.pydata.org/bokeh/release/bokeh-api-${bokeh_version}.min.js`
+	];
+
+	let loaded = false;
+	async function load_plugins(): HTMLScriptElement[] {
+		await Promise.all(
+			plugins_src.map((src, i) => {
+				return new Promise((resolve) => {
+					const script = document.createElement("script");
+					script.onload = resolve;
+					script.src = src;
+					document.head.appendChild(script);
+					return script;
+				});
+			})
+		);
+
+		loaded = true;
+	}
+
+	let plugin_scripts = [];
+
+	function handle_bokeh_loaded(): void {
+		plugin_scripts = load_plugins();
+	}
+
+	function load_bokeh(): HTMLScriptElement {
+		const script = document.createElement("script");
+		script.onload = handle_bokeh_loaded;
+		script.src = main_src;
+		const is_bokeh_script_present = document.head.querySelector(
+			`script[src="${main_src}"]`
+		);
+		if (!is_bokeh_script_present) {
+			document.head.appendChild(script);
+		} else {
+			handle_bokeh_loaded();
+		}
+		return script;
+	}
+
+	const main_script = bokeh_version ? load_bokeh() : null;
+
+	onDestroy(() => {
+		if (main_script in document.children) {
+			document.removeChild(main_script);
+			plugin_scripts.forEach((child) => document.removeChild(child));
+		}
+	});
+</script>
+
+<div data-testid={"bokeh"} id={div_id} class="gradio-bokeh" />
+
+<style>
+	.gradio-bokeh {
+		display: flex;
+		justify-content: center;
+	}
+</style>

6.0.0-dev.6/plot/shared/plot_types/MatplotlibPlot.svelte

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

6.0.0-dev.6/plot/shared/plot_types/PlotlyPlot.svelte

@@ -0,0 +1,52 @@
+<script lang="ts">
+	//@ts-nocheck
+	import Plotly from "plotly.js-dist-min";
+	import { afterUpdate } from "svelte";
+
+	export let value;
+	export let show_label: boolean;
+	export let loaded_plotly_css = false;
+
+	$: plot = value?.plot;
+
+	let plot_div;
+	let plotly_global_style;
+
+	function load_plotly_css(): void {
+		if (!loaded_plotly_css) {
+			plotly_global_style = document.getElementById("plotly.js-style-global");
+			const plotly_style_clone = plotly_global_style.cloneNode();
+			plot_div.appendChild(plotly_style_clone);
+			for (const rule of plotly_global_style.sheet.cssRules) {
+				plotly_style_clone.sheet.insertRule(rule.cssText);
+			}
+			loaded_plotly_css = true;
+		}
+	}
+
+	afterUpdate(async () => {
+		load_plotly_css();
+
+		let plotObj = JSON.parse(plot);
+
+		// the docs aren't very good but this works
+		plotObj.config = plotObj.config || {};
+		plotObj.config.responsive = true;
+		plotObj.responsive = true;
+		plotObj.layout.autosize = true;
+
+		if (plotObj.layout.margin == undefined) {
+			plotObj.layout.margin = {};
+		}
+		if (plotObj.layout.title && show_label) {
+			// so title does not get cut off by label
+			plotObj.layout.margin.t = Math.max(100, plotObj.layout.margin.t || 0);
+		}
+		plotObj.layout.margin.autoexpand = true;
+
+		Plotly.react(plot_div, plotObj.data, plotObj.layout, plotObj.config);
+		Plotly.Plots.resize(plot_div);
+	});
+</script>
+
+<div data-testid={"plotly"} bind:this={plot_div}></div>

6.0.0-dev.6/plot/shared/plot_types/altair_utils.ts

@@ -0,0 +1,111 @@
+import { colors as color_palette } from "@gradio/theme";
+import { get_next_color } from "@gradio/utils";
+import type { Config, TopLevelSpec as Spec } from "vega-lite";
+
+export function set_config(
+	spec: Spec,
+	computed_style: CSSStyleDeclaration,
+	chart_type: string,
+	colors: string[]
+): Spec {
+	let accentColor = computed_style.getPropertyValue("--color-accent");
+	let bodyTextColor = computed_style.getPropertyValue("--body-text-color");
+	let borderColorPrimary = computed_style.getPropertyValue(
+		"--border-color-primary"
+	);
+	let fontFamily = computed_style.fontFamily;
+	let titleWeight = computed_style.getPropertyValue(
+		"--block-title-text-weight"
+	) as "bold" | "normal" | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900;
+	const fontToPxVal = (font: string): number => {
+		return font.endsWith("px") ? parseFloat(font.slice(0, -2)) : 12;
+	};
+	let textSizeMd = fontToPxVal(computed_style.getPropertyValue("--text-md"));
+	let textSizeSm = fontToPxVal(computed_style.getPropertyValue("--text-sm"));
+	let config: Config = {
+		autosize: { type: "fit", contains: "padding" },
+		axis: {
+			labelFont: fontFamily,
+			labelColor: bodyTextColor,
+			titleFont: fontFamily,
+			titleColor: bodyTextColor,
+			tickColor: borderColorPrimary,
+			labelFontSize: textSizeSm,
+			gridColor: borderColorPrimary,
+			titleFontWeight: "normal",
+			titleFontSize: textSizeSm,
+			labelFontWeight: "normal",
+			domain: false,
+			labelAngle: 0
+		},
+		legend: {
+			labelColor: bodyTextColor,
+			labelFont: fontFamily,
+			titleColor: bodyTextColor,
+			titleFont: fontFamily,
+			titleFontWeight: "normal",
+			titleFontSize: textSizeSm,
+			labelFontWeight: "normal",
+			offset: 2
+		},
+		title: {
+			color: bodyTextColor,
+			font: fontFamily,
+			fontSize: textSizeMd,
+			fontWeight: titleWeight,
+			anchor: "middle"
+		},
+		view: {
+			stroke: borderColorPrimary
+		}
+	};
+	spec.config = config;
+	// @ts-ignore (unsure why the following are not typed in Spec)
+	let encoding: any = spec.encoding;
+	// @ts-ignore
+	let layer: any = spec.layer;
+	switch (chart_type) {
+		case "scatter":
+			spec.config.mark = { stroke: accentColor };
+			if (encoding.color && encoding.color.type == "nominal") {
+				encoding.color.scale.range = encoding.color.scale.range.map(
+					(_: string, i: number) => get_color(colors, i)
+				);
+			} else if (encoding.color && encoding.color.type == "quantitative") {
+				encoding.color.scale.range = ["#eff6ff", "#1e3a8a"];
+				encoding.color.scale.range.interpolate = "hsl";
+			}
+			break;
+		case "line":
+			spec.config.mark = { stroke: accentColor, cursor: "crosshair" };
+			layer.forEach((d: any) => {
+				if (d.encoding.color) {
+					d.encoding.color.scale.range = d.encoding.color.scale.range.map(
+						(_: any, i: any) => get_color(colors, i)
+					);
+				}
+			});
+			break;
+		case "bar":
+			spec.config.mark = { opacity: 0.8, fill: accentColor };
+			if (encoding.color) {
+				encoding.color.scale.range = encoding.color.scale.range.map(
+					(_: any, i: any) => get_color(colors, i)
+				);
+			}
+			break;
+	}
+	return spec;
+}
+
+function get_color(colors: string[], index: number): string {
+	let current_color = colors[index % colors.length];
+
+	if (current_color && current_color in color_palette) {
+		return color_palette[current_color as keyof typeof color_palette]?.primary;
+	} else if (!current_color) {
+		return color_palette[get_next_color(index) as keyof typeof color_palette]
+			.primary;
+	}
+	return current_color;
+}

6.0.0-dev.6/plot/types.ts

@@ -0,0 +1,21 @@
+import type { SelectData } from "@gradio/utils";
+import type { LoadingStatus } from "@gradio/statustracker";
+
+export type ThemeMode = "system" | "light" | "dark";
+
+export interface PlotProps {
+	value: null | string;
+	theme_mode: ThemeMode;
+	caption: string;
+	bokeh_version: string | null;
+	show_actions_button: boolean;
+	_selectable: boolean;
+	x_lim: [number, number] | null;
+	show_fullscreen_button: boolean;
+}
+
+export interface PlotEvents {
+	change: never;
+	select: SelectData;
+	clear_status: LoadingStatus;
+}