Upload folder using huggingface_hub

5.49.1/plot/Index.svelte

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

5.49.1/plot/package.json

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

5.49.1/plot/shared/Plot.svelte

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

5.49.1/plot/shared/plot_types/AltairPlot.svelte

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

5.49.1/plot/shared/plot_types/BokehPlot.svelte

@@ -0,0 +1,94 @@
+<script lang="ts">
+	//@ts-nocheck
+	import { onDestroy, createEventDispatcher } from "svelte";
+
+	export let value;
+	export let bokeh_version: string | null;
+	const div_id = `bokehDiv-${Math.random().toString(5).substring(2)}`;
+	const dispatch = createEventDispatcher<{ load: undefined }>();
+	$: 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);
+			const y = await window.Bokeh.embed.embed_item(plotObj, div_id);
+			y._roots.forEach(async (p) => {
+				await p.ready;
+				dispatch("load");
+			});
+		}
+	}
+
+	$: 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>

5.49.1/plot/shared/plot_types/MatplotlibPlot.svelte

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

5.49.1/plot/shared/plot_types/PlotlyPlot.svelte

@@ -0,0 +1,58 @@
+<script lang="ts">
+	//@ts-nocheck
+	import Plotly from "plotly.js-dist-min";
+	import { afterUpdate, createEventDispatcher } 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;
+
+	const dispatch = createEventDispatcher<{ load: undefined }>();
+
+	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);
+
+		plot_div.on("plotly_afterplot", () => {
+			dispatch("load");
+		});
+	});
+</script>
+
+<div data-testid={"plotly"} bind:this={plot_div} />

5.49.1/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;
+}