update module gradio

update module gradio files

.gitattributes

@@ -32,3 +32,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+gradio/templates/cdn/assets/index.3c2bfbb6.js.map filter=lfs diff=lfs merge=lfs -text
+gradio/templates/frontend/assets/index.756cf7e0.js.map filter=lfs diff=lfs merge=lfs -text

gradio/.dockerignore

@@ -0,0 +1,2 @@
+templates/frontend
+templates/frontend/**/*

gradio/__init__.py

@@ -0,0 +1,93 @@
+import pkgutil
+
+import gradio.components as components
+import gradio.inputs as inputs
+import gradio.outputs as outputs
+import gradio.processing_utils
+import gradio.templates
+import gradio.themes as themes
+from gradio.blocks import Blocks
+from gradio.components import (
+    HTML,
+    JSON,
+    Audio,
+    BarPlot,
+    Button,
+    Carousel,
+    Chatbot,
+    Checkbox,
+    Checkboxgroup,
+    CheckboxGroup,
+    Code,
+    ColorPicker,
+    DataFrame,
+    Dataframe,
+    Dataset,
+    Dropdown,
+    File,
+    Gallery,
+    Highlight,
+    Highlightedtext,
+    HighlightedText,
+    Image,
+    Interpretation,
+    Json,
+    Label,
+    LinePlot,
+    Markdown,
+    Model3D,
+    Number,
+    Plot,
+    Radio,
+    ScatterPlot,
+    Slider,
+    State,
+    StatusTracker,
+    Text,
+    Textbox,
+    TimeSeries,
+    Timeseries,
+    UploadButton,
+    Variable,
+    Video,
+    component,
+)
+from gradio.events import SelectData
+from gradio.exceptions import Error
+from gradio.flagging import (
+    CSVLogger,
+    FlaggingCallback,
+    HuggingFaceDatasetJSONSaver,
+    HuggingFaceDatasetSaver,
+    SimpleCSVLogger,
+)
+from gradio.helpers import EventData, Progress
+from gradio.helpers import create_examples as Examples
+from gradio.helpers import make_waveform, skip, update
+from gradio.interface import Interface, TabbedInterface, close_all
+from gradio.ipython_ext import load_ipython_extension
+from gradio.layouts import Accordion, Box, Column, Group, Row, Tab, TabItem, Tabs
+from gradio.mix import Parallel, Series
+from gradio.routes import Request, mount_gradio_app
+from gradio.templates import (
+    Files,
+    ImageMask,
+    ImagePaint,
+    List,
+    Matrix,
+    Mic,
+    Microphone,
+    Numpy,
+    Paint,
+    Pil,
+    PlayableVideo,
+    Sketchpad,
+    TextArea,
+    Webcam,
+)
+from gradio.themes import Base as Theme
+
+current_pkg_version = (
+    (pkgutil.get_data(__name__, "version.txt") or b"").decode("ascii").strip()
+)
+__version__ = current_pkg_version

gradio/blocks.py

@@ -0,0 +1,1779 @@
+from __future__ import annotations
+
+import copy
+import inspect
+import json
+import os
+import random
+import secrets
+import sys
+import time
+import warnings
+import webbrowser
+from abc import abstractmethod
+from types import ModuleType
+from typing import TYPE_CHECKING, Any, Callable, Dict, Iterator, List, Set, Tuple, Type
+
+import anyio
+import requests
+from anyio import CapacityLimiter
+from typing_extensions import Literal
+
+from gradio import components, external, networking, queueing, routes, strings, utils
+from gradio.context import Context
+from gradio.deprecation import check_deprecated_parameters
+from gradio.documentation import document, set_documentation_group
+from gradio.exceptions import DuplicateBlockError, InvalidApiName
+from gradio.helpers import EventData, create_tracker, skip, special_args
+from gradio.themes import Default as DefaultTheme
+from gradio.themes import ThemeClass as Theme
+from gradio.tunneling import CURRENT_TUNNELS
+from gradio.utils import (
+    GRADIO_VERSION,
+    TupleNoPrint,
+    check_function_inputs_match,
+    component_or_layout_class,
+    delete_none,
+    get_cancel_function,
+    get_continuous_fn,
+)
+
+set_documentation_group("blocks")
+
+if TYPE_CHECKING:  # Only import for type checking (is False at runtime).
+    import comet_ml
+    from fastapi.applications import FastAPI
+
+    from gradio.components import Component
+
+
+class Block:
+    def __init__(
+        self,
+        *,
+        render: bool = True,
+        elem_id: str | None = None,
+        elem_classes: List[str] | str | None = None,
+        visible: bool = True,
+        root_url: str | None = None,  # URL that is prepended to all file paths
+        _skip_init_processing: bool = False,  # Used for loading from Spaces
+        **kwargs,
+    ):
+        self._id = Context.id
+        Context.id += 1
+        self.visible = visible
+        self.elem_id = elem_id
+        self.elem_classes = (
+            [elem_classes] if isinstance(elem_classes, str) else elem_classes
+        )
+        self.root_url = root_url
+        self.share_token = secrets.token_urlsafe(32)
+        self._skip_init_processing = _skip_init_processing
+        self._style = {}
+        self.parent: BlockContext | None = None
+        self.root = ""
+
+        if render:
+            self.render()
+        check_deprecated_parameters(self.__class__.__name__, **kwargs)
+
+    def render(self):
+        """
+        Adds self into appropriate BlockContext
+        """
+        if Context.root_block is not None and self._id in Context.root_block.blocks:
+            raise DuplicateBlockError(
+                f"A block with id: {self._id} has already been rendered in the current Blocks."
+            )
+        if Context.block is not None:
+            Context.block.add(self)
+        if Context.root_block is not None:
+            Context.root_block.blocks[self._id] = self
+            if isinstance(self, components.TempFileManager):
+                Context.root_block.temp_file_sets.append(self.temp_files)
+        return self
+
+    def unrender(self):
+        """
+        Removes self from BlockContext if it has been rendered (otherwise does nothing).
+        Removes self from the layout and collection of blocks, but does not delete any event triggers.
+        """
+        if Context.block is not None:
+            try:
+                Context.block.children.remove(self)
+            except ValueError:
+                pass
+        if Context.root_block is not None:
+            try:
+                del Context.root_block.blocks[self._id]
+            except KeyError:
+                pass
+        return self
+
+    def get_block_name(self) -> str:
+        """
+        Gets block's class name.
+
+        If it is template component it gets the parent's class name.
+
+        @return: class name
+        """
+        return (
+            self.__class__.__base__.__name__.lower()
+            if hasattr(self, "is_template")
+            else self.__class__.__name__.lower()
+        )
+
+    def get_expected_parent(self) -> Type[BlockContext] | None:
+        return None
+
+    def set_event_trigger(
+        self,
+        event_name: str,
+        fn: Callable | None,
+        inputs: Component | List[Component] | Set[Component] | None,
+        outputs: Component | List[Component] | None,
+        preprocess: bool = True,
+        postprocess: bool = True,
+        scroll_to_output: bool = False,
+        show_progress: bool = True,
+        api_name: str | None = None,
+        js: str | None = None,
+        no_target: bool = False,
+        queue: bool | None = None,
+        batch: bool = False,
+        max_batch_size: int = 4,
+        cancels: List[int] | None = None,
+        every: float | None = None,
+        collects_event_data: bool | None = None,
+        trigger_after: int | None = None,
+        trigger_only_on_success: bool = False,
+    ) -> Tuple[Dict[str, Any], int]:
+        """
+        Adds an event to the component's dependencies.
+        Parameters:
+            event_name: event name
+            fn: Callable function
+            inputs: input list
+            outputs: output list
+            preprocess: whether to run the preprocess methods of components
+            postprocess: whether to run the postprocess methods of components
+            scroll_to_output: whether to scroll to output of dependency on trigger
+            show_progress: whether to show progress animation while running.
+            api_name: Defining this parameter exposes the endpoint in the api docs
+            js: Optional frontend js method to run before running 'fn'. Input arguments for js method are values of 'inputs' and 'outputs', return should be a list of values for output components
+            no_target: if True, sets "targets" to [], used for Blocks "load" event
+            batch: whether this function takes in a batch of inputs
+            max_batch_size: the maximum batch size to send to the function
+            cancels: a list of other events to cancel when this event is triggered. For example, setting cancels=[click_event] will cancel the click_event, where click_event is the return value of another components .click method.
+            every: Run this event 'every' number of seconds while the client connection is open. Interpreted in seconds. Queue must be enabled.
+            collects_event_data: whether to collect event data for this event
+            trigger_after: if set, this event will be triggered after 'trigger_after' function index
+            trigger_only_on_success: if True, this event will only be triggered if the previous event was successful (only applies if `trigger_after` is set)
+        Returns: dependency information, dependency index
+        """
+        # Support for singular parameter
+        if isinstance(inputs, set):
+            inputs_as_dict = True
+            inputs = sorted(inputs, key=lambda x: x._id)
+        else:
+            inputs_as_dict = False
+            if inputs is None:
+                inputs = []
+            elif not isinstance(inputs, list):
+                inputs = [inputs]
+
+        if isinstance(outputs, set):
+            outputs = sorted(outputs, key=lambda x: x._id)
+        else:
+            if outputs is None:
+                outputs = []
+            elif not isinstance(outputs, list):
+                outputs = [outputs]
+
+        if fn is not None and not cancels:
+            check_function_inputs_match(fn, inputs, inputs_as_dict)
+
+        if Context.root_block is None:
+            raise AttributeError(
+                f"{event_name}() and other events can only be called within a Blocks context."
+            )
+        if every is not None and every <= 0:
+            raise ValueError("Parameter every must be positive or None")
+        if every and batch:
+            raise ValueError(
+                f"Cannot run {event_name} event in a batch and every {every} seconds. "
+                "Either batch is True or every is non-zero but not both."
+            )
+
+        if every and fn:
+            fn = get_continuous_fn(fn, every)
+        elif every:
+            raise ValueError("Cannot set a value for `every` without a `fn`.")
+
+        _, progress_index, event_data_index = (
+            special_args(fn) if fn else (None, None, None)
+        )
+        Context.root_block.fns.append(
+            BlockFunction(
+                fn,
+                inputs,
+                outputs,
+                preprocess,
+                postprocess,
+                inputs_as_dict,
+                progress_index is not None,
+            )
+        )
+        if api_name is not None:
+            api_name_ = utils.append_unique_suffix(
+                api_name, [dep["api_name"] for dep in Context.root_block.dependencies]
+            )
+            if not (api_name == api_name_):
+                warnings.warn(
+                    "api_name {} already exists, using {}".format(api_name, api_name_)
+                )
+                api_name = api_name_
+
+        if collects_event_data is None:
+            collects_event_data = event_data_index is not None
+
+        dependency = {
+            "targets": [self._id] if not no_target else [],
+            "trigger": event_name,
+            "inputs": [block._id for block in inputs],
+            "outputs": [block._id for block in outputs],
+            "backend_fn": fn is not None,
+            "js": js,
+            "queue": False if fn is None else queue,
+            "api_name": api_name,
+            "scroll_to_output": scroll_to_output,
+            "show_progress": show_progress,
+            "every": every,
+            "batch": batch,
+            "max_batch_size": max_batch_size,
+            "cancels": cancels or [],
+            "types": {
+                "continuous": bool(every),
+                "generator": inspect.isgeneratorfunction(fn) or bool(every),
+            },
+            "collects_event_data": collects_event_data,
+            "trigger_after": trigger_after,
+            "trigger_only_on_success": trigger_only_on_success,
+        }
+        Context.root_block.dependencies.append(dependency)
+        return dependency, len(Context.root_block.dependencies) - 1
+
+    def get_config(self):
+        return {
+            "visible": self.visible,
+            "elem_id": self.elem_id,
+            "elem_classes": self.elem_classes,
+            "style": self._style,
+            "root_url": self.root_url,
+        }
+
+    @staticmethod
+    @abstractmethod
+    def update(**kwargs) -> Dict:
+        return {}
+
+    @classmethod
+    def get_specific_update(cls, generic_update: Dict[str, Any]) -> Dict:
+        generic_update = generic_update.copy()
+        del generic_update["__type__"]
+        specific_update = cls.update(**generic_update)
+        return specific_update
+
+
+class BlockContext(Block):
+    def __init__(
+        self,
+        visible: bool = True,
+        render: bool = True,
+        **kwargs,
+    ):
+        """
+        Parameters:
+            visible: If False, this will be hidden but included in the Blocks config file (its visibility can later be updated).
+            render: If False, this will not be included in the Blocks config file at all.
+        """
+        self.children: List[Block] = []
+        Block.__init__(self, visible=visible, render=render, **kwargs)
+
+    def __enter__(self):
+        self.parent = Context.block
+        Context.block = self
+        return self
+
+    def add(self, child: Block):
+        child.parent = self
+        self.children.append(child)
+
+    def fill_expected_parents(self):
+        children = []
+        pseudo_parent = None
+        for child in self.children:
+            expected_parent = child.get_expected_parent()
+            if not expected_parent or isinstance(self, expected_parent):
+                pseudo_parent = None
+                children.append(child)
+            else:
+                if pseudo_parent is not None and isinstance(
+                    pseudo_parent, expected_parent
+                ):
+                    pseudo_parent.children.append(child)
+                else:
+                    pseudo_parent = expected_parent(render=False)
+                    children.append(pseudo_parent)
+                    pseudo_parent.children = [child]
+                    if Context.root_block:
+                        Context.root_block.blocks[pseudo_parent._id] = pseudo_parent
+                child.parent = pseudo_parent
+        self.children = children
+
+    def __exit__(self, *args):
+        if getattr(self, "allow_expected_parents", True):
+            self.fill_expected_parents()
+        Context.block = self.parent
+
+    def postprocess(self, y):
+        """
+        Any postprocessing needed to be performed on a block context.
+        """
+        return y
+
+
+class BlockFunction:
+    def __init__(
+        self,
+        fn: Callable | None,
+        inputs: List[Component],
+        outputs: List[Component],
+        preprocess: bool,
+        postprocess: bool,
+        inputs_as_dict: bool,
+        tracks_progress: bool = False,
+    ):
+        self.fn = fn
+        self.inputs = inputs
+        self.outputs = outputs
+        self.preprocess = preprocess
+        self.postprocess = postprocess
+        self.tracks_progress = tracks_progress
+        self.total_runtime = 0
+        self.total_runs = 0
+        self.inputs_as_dict = inputs_as_dict
+        self.name = getattr(fn, "__name__", "fn") if fn is not None else None
+
+    def __str__(self):
+        return str(
+            {
+                "fn": self.name,
+                "preprocess": self.preprocess,
+                "postprocess": self.postprocess,
+            }
+        )
+
+    def __repr__(self):
+        return str(self)
+
+
+class class_or_instancemethod(classmethod):
+    def __get__(self, instance, type_):
+        descr_get = super().__get__ if instance is None else self.__func__.__get__
+        return descr_get(instance, type_)
+
+
+def postprocess_update_dict(block: Block, update_dict: Dict, postprocess: bool = True):
+    """
+    Converts a dictionary of updates into a format that can be sent to the frontend.
+    E.g. {"__type__": "generic_update", "value": "2", "interactive": False}
+    Into -> {"__type__": "update", "value": 2.0, "mode": "static"}
+
+    Parameters:
+        block: The Block that is being updated with this update dictionary.
+        update_dict: The original update dictionary
+        postprocess: Whether to postprocess the "value" key of the update dictionary.
+    """
+    if update_dict.get("__type__", "") == "generic_update":
+        update_dict = block.get_specific_update(update_dict)
+    if update_dict.get("value") is components._Keywords.NO_VALUE:
+        update_dict.pop("value")
+    interactive = update_dict.pop("interactive", None)
+    if interactive is not None:
+        update_dict["mode"] = "dynamic" if interactive else "static"
+    prediction_value = delete_none(update_dict, skip_value=True)
+    if "value" in prediction_value and postprocess:
+        assert isinstance(
+            block, components.IOComponent
+        ), f"Component {block.__class__} does not support value"
+        prediction_value["value"] = block.postprocess(prediction_value["value"])
+    return prediction_value
+
+
+def convert_component_dict_to_list(
+    outputs_ids: List[int], predictions: Dict
+) -> List | Dict:
+    """
+    Converts a dictionary of component updates into a list of updates in the order of
+    the outputs_ids and including every output component. Leaves other types of dictionaries unchanged.
+    E.g. {"textbox": "hello", "number": {"__type__": "generic_update", "value": "2"}}
+    Into -> ["hello", {"__type__": "generic_update"}, {"__type__": "generic_update", "value": "2"}]
+    """
+    keys_are_blocks = [isinstance(key, Block) for key in predictions.keys()]
+    if all(keys_are_blocks):
+        reordered_predictions = [skip() for _ in outputs_ids]
+        for component, value in predictions.items():
+            if component._id not in outputs_ids:
+                raise ValueError(
+                    f"Returned component {component} not specified as output of function."
+                )
+            output_index = outputs_ids.index(component._id)
+            reordered_predictions[output_index] = value
+        predictions = utils.resolve_singleton(reordered_predictions)
+    elif any(keys_are_blocks):
+        raise ValueError(
+            "Returned dictionary included some keys as Components. Either all keys must be Components to assign Component values, or return a List of values to assign output values in order."
+        )
+    return predictions
+
+
+@document("launch", "queue", "integrate", "load")
+class Blocks(BlockContext):
+    """
+    Blocks is Gradio's low-level API that allows you to create more custom web
+    applications and demos than Interfaces (yet still entirely in Python).
+
+
+    Compared to the Interface class, Blocks offers more flexibility and control over:
+    (1) the layout of components (2) the events that
+    trigger the execution of functions (3) data flows (e.g. inputs can trigger outputs,
+    which can trigger the next level of outputs). Blocks also offers ways to group
+    together related demos such as with tabs.
+
+
+    The basic usage of Blocks is as follows: create a Blocks object, then use it as a
+    context (with the "with" statement), and then define layouts, components, or events
+    within the Blocks context. Finally, call the launch() method to launch the demo.
+
+    Example:
+        import gradio as gr
+        def update(name):
+            return f"Welcome to Gradio, {name}!"
+
+        with gr.Blocks() as demo:
+            gr.Markdown("Start typing below and then click **Run** to see the output.")
+            with gr.Row():
+                inp = gr.Textbox(placeholder="What is your name?")
+                out = gr.Textbox()
+            btn = gr.Button("Run")
+            btn.click(fn=update, inputs=inp, outputs=out)
+
+        demo.launch()
+    Demos: blocks_hello, blocks_flipper, blocks_speech_text_sentiment, generate_english_german, sound_alert
+    Guides: blocks_and_event_listeners, controlling_layout, state_in_blocks, custom_CSS_and_JS, custom_interpretations_with_blocks, using_blocks_like_functions
+    """
+
+    def __init__(
+        self,
+        theme: Theme | str | None = None,
+        analytics_enabled: bool | None = None,
+        mode: str = "blocks",
+        title: str = "Gradio",
+        css: str | None = None,
+        **kwargs,
+    ):
+        """
+        Parameters:
+            analytics_enabled: whether to allow basic telemetry. If None, will use GRADIO_ANALYTICS_ENABLED environment variable or default to True.
+            mode: a human-friendly name for the kind of Blocks or Interface being created.
+            title: The tab title to display when this is opened in a browser window.
+            css: custom css or path to custom css file to apply to entire Blocks
+        """
+        # Cleanup shared parameters with Interface #TODO: is this part still necessary after Interface with Blocks?
+        self.limiter = None
+        self.save_to = None
+        if theme is None:
+            theme = DefaultTheme()
+        elif isinstance(theme, str):
+            try:
+                theme = Theme.from_hub(theme)
+            except Exception as e:
+                warnings.warn(f"Cannot load {theme}. Caught Exception: {str(e)}")
+                theme = DefaultTheme()
+        if not isinstance(theme, Theme):
+            warnings.warn("Theme should be a class loaded from gradio.themes")
+            theme = DefaultTheme()
+        self.theme = theme
+        self.theme_css = theme._get_theme_css()
+        self.stylesheets = theme._stylesheets
+        self.encrypt = False
+        self.share = False
+        self.enable_queue = None
+        self.max_threads = 40
+        self.show_error = True
+        if css is not None and os.path.exists(css):
+            with open(css) as css_file:
+                self.css = css_file.read()
+        else:
+            self.css = css
+
+        # For analytics_enabled and allow_flagging: (1) first check for
+        # parameter, (2) check for env variable, (3) default to True/"manual"
+        self.analytics_enabled = (
+            analytics_enabled
+            if analytics_enabled is not None
+            else os.getenv("GRADIO_ANALYTICS_ENABLED", "True") == "True"
+        )
+        if not self.analytics_enabled:
+            os.environ["HF_HUB_DISABLE_TELEMETRY"] = "True"
+        super().__init__(render=False, **kwargs)
+        self.blocks: Dict[int, Block] = {}
+        self.fns: List[BlockFunction] = []
+        self.dependencies = []
+        self.mode = mode
+
+        self.is_running = False
+        self.local_url = None
+        self.share_url = None
+        self.width = None
+        self.height = None
+        self.api_open = True
+
+        self.is_space = True if os.getenv("SYSTEM") == "spaces" else False
+        self.favicon_path = None
+        self.auth = None
+        self.dev_mode = True
+        self.app_id = random.getrandbits(64)
+        self.temp_file_sets = []
+        self.title = title
+        self.show_api = True
+
+        # Only used when an Interface is loaded from a config
+        self.predict = None
+        self.input_components = None
+        self.output_components = None
+        self.__name__ = None
+        self.api_mode = None
+        self.progress_tracking = None
+
+        self.file_directories = []
+
+        if self.analytics_enabled:
+            data = {
+                "mode": self.mode,
+                "custom_css": self.css is not None,
+                "theme": self.theme,
+                "version": GRADIO_VERSION,
+            }
+            utils.initiated_analytics(data)
+
+    @classmethod
+    def from_config(
+        cls,
+        config: dict,
+        fns: List[Callable],
+        root_url: str | None = None,
+    ) -> Blocks:
+        """
+        Factory method that creates a Blocks from a config and list of functions.
+
+        Parameters:
+        config: a dictionary containing the configuration of the Blocks.
+        fns: a list of functions that are used in the Blocks. Must be in the same order as the dependencies in the config.
+        root_url: an optional root url to use for the components in the Blocks. Allows serving files from an external URL.
+        """
+        config = copy.deepcopy(config)
+        components_config = config["components"]
+        original_mapping: Dict[int, Block] = {}
+
+        def get_block_instance(id: int) -> Block:
+            for block_config in components_config:
+                if block_config["id"] == id:
+                    break
+            else:
+                raise ValueError("Cannot find block with id {}".format(id))
+            cls = component_or_layout_class(block_config["type"])
+            block_config["props"].pop("type", None)
+            block_config["props"].pop("name", None)
+            style = block_config["props"].pop("style", None)
+            if block_config["props"].get("root_url") is None and root_url:
+                block_config["props"]["root_url"] = root_url + "/"
+            # Any component has already processed its initial value, so we skip that step here
+            block = cls(**block_config["props"], _skip_init_processing=True)
+            if style and isinstance(block, components.IOComponent):
+                block.style(**style)
+            return block
+
+        def iterate_over_children(children_list):
+            for child_config in children_list:
+                id = child_config["id"]
+                block = get_block_instance(id)
+
+                original_mapping[id] = block
+
+                children = child_config.get("children")
+                if children is not None:
+                    assert isinstance(
+                        block, BlockContext
+                    ), f"Invalid config, Block with id {id} has children but is not a BlockContext."
+                    with block:
+                        iterate_over_children(children)
+
+        derived_fields = ["types"]
+
+        with Blocks() as blocks:
+            # ID 0 should be the root Blocks component
+            original_mapping[0] = Context.root_block or blocks
+
+            iterate_over_children(config["layout"]["children"])
+
+            first_dependency = None
+
+            # add the event triggers
+            for dependency, fn in zip(config["dependencies"], fns):
+                # We used to add a "fake_event" to the config to cache examples
+                # without removing it. This was causing bugs in calling gr.Interface.load
+                # We fixed the issue by removing "fake_event" from the config in examples.py
+                # but we still need to skip these events when loading the config to support
+                # older demos
+                if dependency["trigger"] == "fake_event":
+                    continue
+                for field in derived_fields:
+                    dependency.pop(field, None)
+                targets = dependency.pop("targets")
+                trigger = dependency.pop("trigger")
+                dependency.pop("backend_fn")
+                dependency.pop("documentation", None)
+                dependency["inputs"] = [
+                    original_mapping[i] for i in dependency["inputs"]
+                ]
+                dependency["outputs"] = [
+                    original_mapping[o] for o in dependency["outputs"]
+                ]
+                dependency.pop("status_tracker", None)
+                dependency["preprocess"] = False
+                dependency["postprocess"] = False
+
+                for target in targets:
+                    dependency = original_mapping[target].set_event_trigger(
+                        event_name=trigger, fn=fn, **dependency
+                    )[0]
+                    if first_dependency is None:
+                        first_dependency = dependency
+
+            # Allows some use of Interface-specific methods with loaded Spaces
+            if first_dependency and Context.root_block:
+                blocks.predict = [fns[0]]
+                blocks.input_components = [
+                    Context.root_block.blocks[i] for i in first_dependency["inputs"]
+                ]
+                blocks.output_components = [
+                    Context.root_block.blocks[o] for o in first_dependency["outputs"]
+                ]
+                blocks.__name__ = "Interface"
+                blocks.api_mode = True
+
+        return blocks
+
+    def __str__(self):
+        return self.__repr__()
+
+    def __repr__(self):
+        num_backend_fns = len([d for d in self.dependencies if d["backend_fn"]])
+        repr = f"Gradio Blocks instance: {num_backend_fns} backend functions"
+        repr += "\n" + "-" * len(repr)
+        for d, dependency in enumerate(self.dependencies):
+            if dependency["backend_fn"]:
+                repr += f"\nfn_index={d}"
+                repr += "\n inputs:"
+                for input_id in dependency["inputs"]:
+                    block = self.blocks[input_id]
+                    repr += "\n |-{}".format(str(block))
+                repr += "\n outputs:"
+                for output_id in dependency["outputs"]:
+                    block = self.blocks[output_id]
+                    repr += "\n |-{}".format(str(block))
+        return repr
+
+    def render(self):
+        if Context.root_block is not None:
+            if self._id in Context.root_block.blocks:
+                raise DuplicateBlockError(
+                    f"A block with id: {self._id} has already been rendered in the current Blocks."
+                )
+            if not set(Context.root_block.blocks).isdisjoint(self.blocks):
+                raise DuplicateBlockError(
+                    "At least one block in this Blocks has already been rendered."
+                )
+
+            Context.root_block.blocks.update(self.blocks)
+            Context.root_block.fns.extend(self.fns)
+            dependency_offset = len(Context.root_block.dependencies)
+            for i, dependency in enumerate(self.dependencies):
+                api_name = dependency["api_name"]
+                if api_name is not None:
+                    api_name_ = utils.append_unique_suffix(
+                        api_name,
+                        [dep["api_name"] for dep in Context.root_block.dependencies],
+                    )
+                    if not (api_name == api_name_):
+                        warnings.warn(
+                            "api_name {} already exists, using {}".format(
+                                api_name, api_name_
+                            )
+                        )
+                        dependency["api_name"] = api_name_
+                dependency["cancels"] = [
+                    c + dependency_offset for c in dependency["cancels"]
+                ]
+                if dependency.get("trigger_after") is not None:
+                    dependency["trigger_after"] += dependency_offset
+                # Recreate the cancel function so that it has the latest
+                # dependency fn indices. This is necessary to properly cancel
+                # events in the backend
+                if dependency["cancels"]:
+                    updated_cancels = [
+                        Context.root_block.dependencies[i]
+                        for i in dependency["cancels"]
+                    ]
+                    new_fn = BlockFunction(
+                        get_cancel_function(updated_cancels)[0],
+                        [],
+                        [],
+                        False,
+                        True,
+                        False,
+                    )
+                    Context.root_block.fns[dependency_offset + i] = new_fn
+                Context.root_block.dependencies.append(dependency)
+            Context.root_block.temp_file_sets.extend(self.temp_file_sets)
+
+        if Context.block is not None:
+            Context.block.children.extend(self.children)
+        return self
+
+    def is_callable(self, fn_index: int = 0) -> bool:
+        """Checks if a particular Blocks function is callable (i.e. not stateful or a generator)."""
+        block_fn = self.fns[fn_index]
+        dependency = self.dependencies[fn_index]
+
+        if inspect.isasyncgenfunction(block_fn.fn):
+            return False
+        if inspect.isgeneratorfunction(block_fn.fn):
+            return False
+        for input_id in dependency["inputs"]:
+            block = self.blocks[input_id]
+            if getattr(block, "stateful", False):
+                return False
+        for output_id in dependency["outputs"]:
+            block = self.blocks[output_id]
+            if getattr(block, "stateful", False):
+                return False
+
+        return True
+
+    def __call__(self, *inputs, fn_index: int = 0, api_name: str | None = None):
+        """
+        Allows Blocks objects to be called as functions. Supply the parameters to the
+        function as positional arguments. To choose which function to call, use the
+        fn_index parameter, which must be a keyword argument.
+
+        Parameters:
+        *inputs: the parameters to pass to the function
+        fn_index: the index of the function to call (defaults to 0, which for Interfaces, is the default prediction function)
+        api_name: The api_name of the dependency to call. Will take precedence over fn_index.
+        """
+        if api_name is not None:
+            inferred_fn_index = next(
+                (
+                    i
+                    for i, d in enumerate(self.dependencies)
+                    if d.get("api_name") == api_name
+                ),
+                None,
+            )
+            if inferred_fn_index is None:
+                raise InvalidApiName(f"Cannot find a function with api_name {api_name}")
+            fn_index = inferred_fn_index
+        if not (self.is_callable(fn_index)):
+            raise ValueError(
+                "This function is not callable because it is either stateful or is a generator. Please use the .launch() method instead to create an interactive user interface."
+            )
+
+        inputs = list(inputs)
+        processed_inputs = self.serialize_data(fn_index, inputs)
+        batch = self.dependencies[fn_index]["batch"]
+        if batch:
+            processed_inputs = [[inp] for inp in processed_inputs]
+
+        outputs = utils.synchronize_async(
+            self.process_api,
+            fn_index=fn_index,
+            inputs=processed_inputs,
+            request=None,
+            state={},
+        )
+        outputs = outputs["data"]
+
+        if batch:
+            outputs = [out[0] for out in outputs]
+
+        processed_outputs = self.deserialize_data(fn_index, outputs)
+        processed_outputs = utils.resolve_singleton(processed_outputs)
+
+        return processed_outputs
+
+    async def call_function(
+        self,
+        fn_index: int,
+        processed_input: List[Any],
+        iterator: Iterator[Any] | None = None,
+        requests: routes.Request | List[routes.Request] | None = None,
+        event_id: str | None = None,
+        event_data: EventData | None = None,
+    ):
+        """
+        Calls function with given index and preprocessed input, and measures process time.
+        Parameters:
+            fn_index: index of function to call
+            processed_input: preprocessed input to pass to function
+            iterator: iterator to use if function is a generator
+            requests: requests to pass to function
+            event_id: id of event in queue
+            event_data: data associated with event trigger
+        """
+        block_fn = self.fns[fn_index]
+        assert block_fn.fn, f"function with index {fn_index} not defined."
+        is_generating = False
+
+        if block_fn.inputs_as_dict:
+            processed_input = [
+                {
+                    input_component: data
+                    for input_component, data in zip(block_fn.inputs, processed_input)
+                }
+            ]
+
+        if isinstance(requests, list):
+            request = requests[0]
+        else:
+            request = requests
+        processed_input, progress_index, _ = special_args(
+            block_fn.fn, processed_input, request, event_data
+        )
+        progress_tracker = (
+            processed_input[progress_index] if progress_index is not None else None
+        )
+
+        start = time.time()
+
+        if iterator is None:  # If not a generator function that has already run
+            if progress_tracker is not None and progress_index is not None:
+                progress_tracker, fn = create_tracker(
+                    self, event_id, block_fn.fn, progress_tracker.track_tqdm
+                )
+                processed_input[progress_index] = progress_tracker
+            else:
+                fn = block_fn.fn
+
+            if inspect.iscoroutinefunction(fn):
+                prediction = await fn(*processed_input)
+            else:
+                prediction = await anyio.to_thread.run_sync(
+                    fn, *processed_input, limiter=self.limiter
+                )
+        else:
+            prediction = None
+
+        if inspect.isasyncgenfunction(block_fn.fn):
+            raise ValueError("Gradio does not support async generators.")
+        if inspect.isgeneratorfunction(block_fn.fn):
+            if not self.enable_queue:
+                raise ValueError("Need to enable queue to use generators.")
+            try:
+                if iterator is None:
+                    iterator = prediction
+                prediction = await anyio.to_thread.run_sync(
+                    utils.async_iteration, iterator, limiter=self.limiter
+                )
+                is_generating = True
+            except StopAsyncIteration:
+                n_outputs = len(self.dependencies[fn_index].get("outputs"))
+                prediction = (
+                    components._Keywords.FINISHED_ITERATING
+                    if n_outputs == 1
+                    else (components._Keywords.FINISHED_ITERATING,) * n_outputs
+                )
+                iterator = None
+
+        duration = time.time() - start
+
+        return {
+            "prediction": prediction,
+            "duration": duration,
+            "is_generating": is_generating,
+            "iterator": iterator,
+        }
+
+    def serialize_data(self, fn_index: int, inputs: List[Any]) -> List[Any]:
+        dependency = self.dependencies[fn_index]
+        processed_input = []
+
+        for i, input_id in enumerate(dependency["inputs"]):
+            block = self.blocks[input_id]
+            assert isinstance(
+                block, components.IOComponent
+            ), f"{block.__class__} Component with id {input_id} not a valid input component."
+            serialized_input = block.serialize(inputs[i])
+            processed_input.append(serialized_input)
+
+        return processed_input
+
+    def deserialize_data(self, fn_index: int, outputs: List[Any]) -> List[Any]:
+        dependency = self.dependencies[fn_index]
+        predictions = []
+
+        for o, output_id in enumerate(dependency["outputs"]):
+            block = self.blocks[output_id]
+            assert isinstance(
+                block, components.IOComponent
+            ), f"{block.__class__} Component with id {output_id} not a valid output component."
+            deserialized = block.deserialize(outputs[o], root_url=block.root_url)
+            predictions.append(deserialized)
+
+        return predictions
+
+    def preprocess_data(self, fn_index: int, inputs: List[Any], state: Dict[int, Any]):
+        block_fn = self.fns[fn_index]
+        dependency = self.dependencies[fn_index]
+
+        if block_fn.preprocess:
+            processed_input = []
+            for i, input_id in enumerate(dependency["inputs"]):
+                block = self.blocks[input_id]
+                assert isinstance(
+                    block, components.Component
+                ), f"{block.__class__} Component with id {input_id} not a valid input component."
+                if getattr(block, "stateful", False):
+                    processed_input.append(state.get(input_id))
+                else:
+                    processed_input.append(block.preprocess(inputs[i]))
+        else:
+            processed_input = inputs
+        return processed_input
+
+    def postprocess_data(
+        self, fn_index: int, predictions: List | Dict, state: Dict[int, Any]
+    ):
+        block_fn = self.fns[fn_index]
+        dependency = self.dependencies[fn_index]
+        batch = dependency["batch"]
+
+        if type(predictions) is dict and len(predictions) > 0:
+            predictions = convert_component_dict_to_list(
+                dependency["outputs"], predictions
+            )
+
+        if len(dependency["outputs"]) == 1 and not (batch):
+            predictions = [
+                predictions,
+            ]
+
+        output = []
+        for i, output_id in enumerate(dependency["outputs"]):
+            try:
+                if predictions[i] is components._Keywords.FINISHED_ITERATING:
+                    output.append(None)
+                    continue
+            except (IndexError, KeyError):
+                raise ValueError(
+                    f"Number of output components does not match number of values returned from from function {block_fn.name}"
+                )
+            block = self.blocks[output_id]
+            if getattr(block, "stateful", False):
+                if not utils.is_update(predictions[i]):
+                    state[output_id] = predictions[i]
+                output.append(None)
+            else:
+                prediction_value = predictions[i]
+                if utils.is_update(prediction_value):
+                    assert isinstance(prediction_value, dict)
+                    prediction_value = postprocess_update_dict(
+                        block=block,
+                        update_dict=prediction_value,
+                        postprocess=block_fn.postprocess,
+                    )
+                elif block_fn.postprocess:
+                    assert isinstance(
+                        block, components.Component
+                    ), f"{block.__class__} Component with id {output_id} not a valid output component."
+                    prediction_value = block.postprocess(prediction_value)
+                output.append(prediction_value)
+
+        return output
+
+    async def process_api(
+        self,
+        fn_index: int,
+        inputs: List[Any],
+        state: Dict[int, Any],
+        request: routes.Request | List[routes.Request] | None = None,
+        iterators: Dict[int, Any] | None = None,
+        event_id: str | None = None,
+        event_data: EventData | None = None,
+    ) -> Dict[str, Any]:
+        """
+        Processes API calls from the frontend. First preprocesses the data,
+        then runs the relevant function, then postprocesses the output.
+        Parameters:
+            fn_index: Index of function to run.
+            inputs: input data received from the frontend
+            username: name of user if authentication is set up (not used)
+            state: data stored from stateful components for session (key is input block id)
+            iterators: the in-progress iterators for each generator function (key is function index)
+            event_id: id of event that triggered this API call
+            event_data: data associated with the event trigger itself
+        Returns: None
+        """
+        block_fn = self.fns[fn_index]
+        batch = self.dependencies[fn_index]["batch"]
+
+        if batch:
+            max_batch_size = self.dependencies[fn_index]["max_batch_size"]
+            batch_sizes = [len(inp) for inp in inputs]
+            batch_size = batch_sizes[0]
+            if inspect.isasyncgenfunction(block_fn.fn) or inspect.isgeneratorfunction(
+                block_fn.fn
+            ):
+                raise ValueError("Gradio does not support generators in batch mode.")
+            if not all(x == batch_size for x in batch_sizes):
+                raise ValueError(
+                    f"All inputs to a batch function must have the same length but instead have sizes: {batch_sizes}."
+                )
+            if batch_size > max_batch_size:
+                raise ValueError(
+                    f"Batch size ({batch_size}) exceeds the max_batch_size for this function ({max_batch_size})"
+                )
+
+            inputs = [
+                self.preprocess_data(fn_index, list(i), state) for i in zip(*inputs)
+            ]
+            result = await self.call_function(
+                fn_index, list(zip(*inputs)), None, request, event_id, event_data
+            )
+            preds = result["prediction"]
+            data = [
+                self.postprocess_data(fn_index, list(o), state) for o in zip(*preds)
+            ]
+            data = list(zip(*data))
+            is_generating, iterator = None, None
+        else:
+            inputs = self.preprocess_data(fn_index, inputs, state)
+            iterator = iterators.get(fn_index, None) if iterators else None
+            result = await self.call_function(
+                fn_index, inputs, iterator, request, event_id, event_data
+            )
+            data = self.postprocess_data(fn_index, result["prediction"], state)
+            is_generating, iterator = result["is_generating"], result["iterator"]
+
+        block_fn.total_runtime += result["duration"]
+        block_fn.total_runs += 1
+
+        return {
+            "data": data,
+            "is_generating": is_generating,
+            "iterator": iterator,
+            "duration": result["duration"],
+            "average_duration": block_fn.total_runtime / block_fn.total_runs,
+        }
+
+    async def create_limiter(self):
+        self.limiter = (
+            None
+            if self.max_threads == 40
+            else CapacityLimiter(total_tokens=self.max_threads)
+        )
+
+    def get_config(self):
+        return {"type": "column"}
+
+    def get_config_file(self):
+        config = {
+            "version": routes.VERSION,
+            "mode": self.mode,
+            "dev_mode": self.dev_mode,
+            "analytics_enabled": self.analytics_enabled,
+            "components": [],
+            "css": self.css,
+            "title": self.title or "Gradio",
+            "is_space": self.is_space,
+            "enable_queue": getattr(self, "enable_queue", False),  # launch attributes
+            "show_error": getattr(self, "show_error", False),
+            "show_api": self.show_api,
+            "is_colab": utils.colab_check(),
+            "stylesheets": self.stylesheets,
+            "root": self.root,
+        }
+
+        def getLayout(block):
+            if not isinstance(block, BlockContext):
+                return {"id": block._id}
+            children_layout = []
+            for child in block.children:
+                children_layout.append(getLayout(child))
+            return {"id": block._id, "children": children_layout}
+
+        config["layout"] = getLayout(self)
+
+        for _id, block in self.blocks.items():
+            config["components"].append(
+                {
+                    "id": _id,
+                    "type": (block.get_block_name()),
+                    "props": utils.delete_none(block.get_config())
+                    if hasattr(block, "get_config")
+                    else {},
+                }
+            )
+        config["dependencies"] = self.dependencies
+        return config
+
+    def __enter__(self):
+        if Context.block is None:
+            Context.root_block = self
+        self.parent = Context.block
+        Context.block = self
+        return self
+
+    def __exit__(self, *args):
+        super().fill_expected_parents()
+        Context.block = self.parent
+        # Configure the load events before root_block is reset
+        self.attach_load_events()
+        if self.parent is None:
+            Context.root_block = None
+        else:
+            self.parent.children.extend(self.children)
+        self.config = self.get_config_file()
+        self.app = routes.App.create_app(self)
+        self.progress_tracking = any(block_fn.tracks_progress for block_fn in self.fns)
+
+    @class_or_instancemethod
+    def load(
+        self_or_cls,
+        fn: Callable | None = None,
+        inputs: List[Component] | None = None,
+        outputs: List[Component] | None = None,
+        api_name: str | None = None,
+        scroll_to_output: bool = False,
+        show_progress: bool = True,
+        queue=None,
+        batch: bool = False,
+        max_batch_size: int = 4,
+        preprocess: bool = True,
+        postprocess: bool = True,
+        every: float | None = None,
+        _js: str | None = None,
+        *,
+        name: str | None = None,
+        src: str | None = None,
+        api_key: str | None = None,
+        alias: str | None = None,
+        **kwargs,
+    ) -> Blocks | Dict[str, Any] | None:
+        """
+        For reverse compatibility reasons, this is both a class method and an instance
+        method, the two of which, confusingly, do two completely different things.
+
+
+        Class method: loads a demo from a Hugging Face Spaces repo and creates it locally and returns a block instance. Equivalent to gradio.Interface.load()
+
+
+        Instance method: adds event that runs as soon as the demo loads in the browser. Example usage below.
+        Parameters:
+            name: Class Method - the name of the model (e.g. "gpt2" or "facebook/bart-base") or space (e.g. "flax-community/spanish-gpt2"), can include the `src` as prefix (e.g. "models/facebook/bart-base")
+            src: Class Method - the source of the model: `models` or `spaces` (or leave empty if source is provided as a prefix in `name`)
+            api_key: Class Method - optional access token for loading private Hugging Face Hub models or spaces. Find your token here: https://huggingface.co/settings/tokens
+            alias: Class Method - optional string used as the name of the loaded model instead of the default name (only applies if loading a Space running Gradio 2.x)
+            fn: Instance Method - the function to wrap an interface around. Often a machine learning model's prediction function. Each parameter of the function corresponds to one input component, and the function should return a single value or a tuple of values, with each element in the tuple corresponding to one output component.
+            inputs: Instance Method - List of gradio.components to use as inputs. If the function takes no inputs, this should be an empty list.
+            outputs: Instance Method - List of gradio.components to use as inputs. If the function returns no outputs, this should be an empty list.
+            api_name: Instance Method - Defining this parameter exposes the endpoint in the api docs
+            scroll_to_output: Instance Method - If True, will scroll to output component on completion
+            show_progress: Instance Method - If True, will show progress animation while pending
+            queue: Instance Method - If True, will place the request on the queue, if the queue exists
+            batch: Instance Method - If True, then the function should process a batch of inputs, meaning that it should accept a list of input values for each parameter. The lists should be of equal length (and be up to length `max_batch_size`). The function is then *required* to return a tuple of lists (even if there is only 1 output component), with each list in the tuple corresponding to one output component.
+            max_batch_size: Instance Method - Maximum number of inputs to batch together if this is called from the queue (only relevant if batch=True)
+            preprocess: Instance Method - If False, will not run preprocessing of component data before running 'fn' (e.g. leaving it as a base64 string if this method is called with the `Image` component).
+            postprocess: Instance Method - If False, will not run postprocessing of component data before returning 'fn' output to the browser.
+            every: Instance Method - Run this event 'every' number of seconds. Interpreted in seconds. Queue must be enabled.
+        Example:
+            import gradio as gr
+            import datetime
+            with gr.Blocks() as demo:
+                def get_time():
+                    return datetime.datetime.now().time()
+                dt = gr.Textbox(label="Current time")
+                demo.load(get_time, inputs=None, outputs=dt)
+            demo.launch()
+        """
+        # _js: Optional frontend js method to run before running 'fn'. Input arguments for js method are values of 'inputs' and 'outputs', return should be a list of values for output components.
+        if isinstance(self_or_cls, type):
+            if name is None:
+                raise ValueError(
+                    "Blocks.load() requires passing parameters as keyword arguments"
+                )
+            return external.load_blocks_from_repo(name, src, api_key, alias, **kwargs)
+        else:
+            return self_or_cls.set_event_trigger(
+                event_name="load",
+                fn=fn,
+                inputs=inputs,
+                outputs=outputs,
+                api_name=api_name,
+                preprocess=preprocess,
+                postprocess=postprocess,
+                scroll_to_output=scroll_to_output,
+                show_progress=show_progress,
+                js=_js,
+                queue=queue,
+                batch=batch,
+                max_batch_size=max_batch_size,
+                every=every,
+                no_target=True,
+            )[0]
+
+    def clear(self):
+        """Resets the layout of the Blocks object."""
+        self.blocks = {}
+        self.fns = []
+        self.dependencies = []
+        self.children = []
+        return self
+
+    @document()
+    def queue(
+        self,
+        concurrency_count: int = 1,
+        status_update_rate: float | Literal["auto"] = "auto",
+        client_position_to_load_data: int | None = None,
+        default_enabled: bool | None = None,
+        api_open: bool = True,
+        max_size: int | None = None,
+    ):
+        """
+        You can control the rate of processed requests by creating a queue. This will allow you to set the number of requests to be processed at one time, and will let users know their position in the queue.
+        Parameters:
+            concurrency_count: Number of worker threads that will be processing requests from the queue concurrently. Increasing this number will increase the rate at which requests are processed, but will also increase the memory usage of the queue.
+            status_update_rate: If "auto", Queue will send status estimations to all clients whenever a job is finished. Otherwise Queue will send status at regular intervals set by this parameter as the number of seconds.
+            client_position_to_load_data: DEPRECATED. This parameter is deprecated and has no effect.
+            default_enabled: Deprecated and has no effect.
+            api_open: If True, the REST routes of the backend will be open, allowing requests made directly to those endpoints to skip the queue.
+            max_size: The maximum number of events the queue will store at any given moment. If the queue is full, new events will not be added and a user will receive a message saying that the queue is full. If None, the queue size will be unlimited.
+        Example: (Blocks)
+            with gr.Blocks() as demo:
+                button = gr.Button(label="Generate Image")
+                button.click(fn=image_generator, inputs=gr.Textbox(), outputs=gr.Image())
+            demo.queue(concurrency_count=3)
+            demo.launch()
+        Example: (Interface)
+            demo = gr.Interface(image_generator, gr.Textbox(), gr.Image())
+            demo.queue(concurrency_count=3)
+            demo.launch()
+        """
+        if default_enabled is not None:
+            warnings.warn(
+                "The default_enabled parameter of queue has no effect and will be removed "
+                "in a future version of gradio."
+            )
+        self.enable_queue = True
+        self.api_open = api_open
+        if client_position_to_load_data is not None:
+            warnings.warn("The client_position_to_load_data parameter is deprecated.")
+        self._queue = queueing.Queue(
+            live_updates=status_update_rate == "auto",
+            concurrency_count=concurrency_count,
+            update_intervals=status_update_rate if status_update_rate != "auto" else 1,
+            max_size=max_size,
+            blocks_dependencies=self.dependencies,
+        )
+        self.config = self.get_config_file()
+        self.app = routes.App.create_app(self)
+        return self
+
+    def launch(
+        self,
+        inline: bool | None = None,
+        inbrowser: bool = False,
+        share: bool | None = None,
+        debug: bool = False,
+        enable_queue: bool | None = None,
+        max_threads: int = 40,
+        auth: Callable | Tuple[str, str] | List[Tuple[str, str]] | None = None,
+        auth_message: str | None = None,
+        prevent_thread_lock: bool = False,
+        show_error: bool = False,
+        server_name: str | None = None,
+        server_port: int | None = None,
+        show_tips: bool = False,
+        height: int = 500,
+        width: int | str = "100%",
+        encrypt: bool | None = None,
+        favicon_path: str | None = None,
+        ssl_keyfile: str | None = None,
+        ssl_certfile: str | None = None,
+        ssl_keyfile_password: str | None = None,
+        quiet: bool = False,
+        show_api: bool = True,
+        file_directories: List[str] | None = None,
+        _frontend: bool = True,
+    ) -> Tuple[FastAPI, str, str]:
+        """
+        Launches a simple web server that serves the demo. Can also be used to create a
+        public link used by anyone to access the demo from their browser by setting share=True.
+
+        Parameters:
+            inline: whether to display in the interface inline in an iframe. Defaults to True in python notebooks; False otherwise.
+            inbrowser: whether to automatically launch the interface in a new tab on the default browser.
+            share: whether to create a publicly shareable link for the interface. Creates an SSH tunnel to make your UI accessible from anywhere. If not provided, it is set to False by default every time, except when running in Google Colab. When localhost is not accessible (e.g. Google Colab), setting share=False is not supported.
+            debug: if True, blocks the main thread from running. If running in Google Colab, this is needed to print the errors in the cell output.
+            auth: If provided, username and password (or list of username-password tuples) required to access interface. Can also provide function that takes username and password and returns True if valid login.
+            auth_message: If provided, HTML message provided on login page.
+            prevent_thread_lock: If True, the interface will block the main thread while the server is running.
+            show_error: If True, any errors in the interface will be displayed in an alert modal and printed in the browser console log
+            server_port: will start gradio app on this port (if available). Can be set by environment variable GRADIO_SERVER_PORT. If None, will search for an available port starting at 7860.
+            server_name: to make app accessible on local network, set this to "0.0.0.0". Can be set by environment variable GRADIO_SERVER_NAME. If None, will use "127.0.0.1".
+            show_tips: if True, will occasionally show tips about new Gradio features
+            enable_queue: DEPRECATED (use .queue() method instead.) if True, inference requests will be served through a queue instead of with parallel threads. Required for longer inference times (> 1min) to prevent timeout. The default option in HuggingFace Spaces is True. The default option elsewhere is False.
+            max_threads: the maximum number of total threads that the Gradio app can generate in parallel. The default is inherited from the starlette library (currently 40). Applies whether the queue is enabled or not. But if queuing is enabled, this parameter is increaseed to be at least the concurrency_count of the queue.
+            width: The width in pixels of the iframe element containing the interface (used if inline=True)
+            height: The height in pixels of the iframe element containing the interface (used if inline=True)
+            encrypt: DEPRECATED. Has no effect.
+            favicon_path: If a path to a file (.png, .gif, or .ico) is provided, it will be used as the favicon for the web page.
+            ssl_keyfile: If a path to a file is provided, will use this as the private key file to create a local server running on https.
+            ssl_certfile: If a path to a file is provided, will use this as the signed certificate for https. Needs to be provided if ssl_keyfile is provided.
+            ssl_keyfile_password: If a password is provided, will use this with the ssl certificate for https.
+            quiet: If True, suppresses most print statements.
+            show_api: If True, shows the api docs in the footer of the app. Default True. If the queue is enabled, then api_open parameter of .queue() will determine if the api docs are shown, independent of the value of show_api.
+            file_directories: List of directories that gradio is allowed to serve files from (in addition to the directory containing the gradio python file). Must be absolute paths. Warning: any files in these directories or its children are potentially accessible to all users of your app.
+        Returns:
+            app: FastAPI app object that is running the demo
+            local_url: Locally accessible link to the demo
+            share_url: Publicly accessible link to the demo (if share=True, otherwise None)
+        Example: (Blocks)
+            import gradio as gr
+            def reverse(text):
+                return text[::-1]
+            with gr.Blocks() as demo:
+                button = gr.Button(value="Reverse")
+                button.click(reverse, gr.Textbox(), gr.Textbox())
+            demo.launch(share=True, auth=("username", "password"))
+        Example:  (Interface)
+            import gradio as gr
+            def reverse(text):
+                return text[::-1]
+            demo = gr.Interface(reverse, "text", "text")
+            demo.launch(share=True, auth=("username", "password"))
+        """
+        self.dev_mode = False
+        if (
+            auth
+            and not callable(auth)
+            and not isinstance(auth[0], tuple)
+            and not isinstance(auth[0], list)
+        ):
+            self.auth = [auth]
+        else:
+            self.auth = auth
+        self.auth_message = auth_message
+        self.show_tips = show_tips
+        self.show_error = show_error
+        self.height = height
+        self.width = width
+        self.favicon_path = favicon_path
+
+        if enable_queue is not None:
+            self.enable_queue = enable_queue
+            warnings.warn(
+                "The `enable_queue` parameter has been deprecated. Please use the `.queue()` method instead.",
+                DeprecationWarning,
+            )
+        if encrypt is not None:
+            warnings.warn(
+                "The `encrypt` parameter has been deprecated and has no effect.",
+                DeprecationWarning,
+            )
+
+        if self.is_space:
+            self.enable_queue = self.enable_queue is not False
+        else:
+            self.enable_queue = self.enable_queue is True
+        if self.enable_queue and not hasattr(self, "_queue"):
+            self.queue()
+        self.show_api = self.api_open if self.enable_queue else show_api
+
+        self.file_directories = file_directories if file_directories is not None else []
+        if not isinstance(self.file_directories, list):
+            raise ValueError("file_directories must be a list of directories.")
+
+        if not self.enable_queue and self.progress_tracking:
+            raise ValueError("Progress tracking requires queuing to be enabled.")
+
+        for dep in self.dependencies:
+            for i in dep["cancels"]:
+                if not self.queue_enabled_for_fn(i):
+                    raise ValueError(
+                        "In order to cancel an event, the queue for that event must be enabled! "
+                        "You may get this error by either 1) passing a function that uses the yield keyword "
+                        "into an interface without enabling the queue or 2) defining an event that cancels "
+                        "another event without enabling the queue. Both can be solved by calling .queue() "
+                        "before .launch()"
+                    )
+            if dep["batch"] and (
+                dep["queue"] is False
+                or (dep["queue"] is None and not self.enable_queue)
+            ):
+                raise ValueError("In order to use batching, the queue must be enabled.")
+
+        self.config = self.get_config_file()
+        self.max_threads = max(
+            self._queue.max_thread_count if self.enable_queue else 0, max_threads
+        )
+
+        if self.is_running:
+            assert isinstance(
+                self.local_url, str
+            ), f"Invalid local_url: {self.local_url}"
+            if not (quiet):
+                print(
+                    "Rerunning server... use `close()` to stop if you need to change `launch()` parameters.\n----"
+                )
+        else:
+            server_name, server_port, local_url, app, server = networking.start_server(
+                self,
+                server_name,
+                server_port,
+                ssl_keyfile,
+                ssl_certfile,
+                ssl_keyfile_password,
+            )
+            self.server_name = server_name
+            self.local_url = local_url
+            self.server_port = server_port
+            self.server_app = app
+            self.server = server
+            self.is_running = True
+            self.is_colab = utils.colab_check()
+            self.is_kaggle = utils.kaggle_check()
+            self.is_sagemaker = utils.sagemaker_check()
+
+            self.protocol = (
+                "https"
+                if self.local_url.startswith("https") or self.is_colab
+                else "http"
+            )
+
+            if self.enable_queue:
+                self._queue.set_url(self.local_url)
+
+            # Cannot run async functions in background other than app's scope.
+            # Workaround by triggering the app endpoint
+            requests.get(f"{self.local_url}startup-events")
+
+        utils.launch_counter()
+
+        if share is None:
+            if self.is_colab and self.enable_queue:
+                if not quiet:
+                    print(
+                        "Setting queue=True in a Colab notebook requires sharing enabled. Setting `share=True` (you can turn this off by setting `share=False` in `launch()` explicitly).\n"
+                    )
+                self.share = True
+            elif self.is_kaggle:
+                if not quiet:
+                    print(
+                        "Kaggle notebooks require sharing enabled. Setting `share=True` (you can turn this off by setting `share=False` in `launch()` explicitly).\n"
+                    )
+                self.share = True
+            elif self.is_sagemaker:
+                if not quiet:
+                    print(
+                        "Sagemaker notebooks may require sharing enabled. Setting `share=True` (you can turn this off by setting `share=False` in `launch()` explicitly).\n"
+                    )
+                self.share = True
+            else:
+                self.share = False
+        else:
+            self.share = share
+
+        # If running in a colab or not able to access localhost,
+        # a shareable link must be created.
+        if _frontend and (not networking.url_ok(self.local_url)) and (not self.share):
+            raise ValueError(
+                "When localhost is not accessible, a shareable link must be created. Please set share=True."
+            )
+
+        if self.is_colab:
+            if not quiet:
+                if debug:
+                    print(strings.en["COLAB_DEBUG_TRUE"])
+                else:
+                    print(strings.en["COLAB_DEBUG_FALSE"])
+                if not self.share:
+                    print(strings.en["COLAB_WARNING"].format(self.server_port))
+            if self.enable_queue and not self.share:
+                raise ValueError(
+                    "When using queueing in Colab, a shareable link must be created. Please set share=True."
+                )
+        else:
+            print(
+                strings.en["RUNNING_LOCALLY_SEPARATED"].format(
+                    self.protocol, self.server_name, self.server_port
+                )
+            )
+
+        if self.share:
+            if self.is_space:
+                raise RuntimeError("Share is not supported when you are in Spaces")
+            try:
+                if self.share_url is None:
+                    self.share_url = networking.setup_tunnel(
+                        self.server_name, self.server_port, self.share_token
+                    )
+                print(strings.en["SHARE_LINK_DISPLAY"].format(self.share_url))
+                if not (quiet):
+                    print(strings.en["SHARE_LINK_MESSAGE"])
+            except (RuntimeError, requests.exceptions.ConnectionError):
+                if self.analytics_enabled:
+                    utils.error_analytics("Not able to set up tunnel")
+                self.share_url = None
+                self.share = False
+                print(strings.en["COULD_NOT_GET_SHARE_LINK"])
+        else:
+            if not (quiet):
+                print(strings.en["PUBLIC_SHARE_TRUE"])
+            self.share_url = None
+
+        if inbrowser:
+            link = self.share_url if self.share and self.share_url else self.local_url
+            webbrowser.open(link)
+
+        # Check if running in a Python notebook in which case, display inline
+        if inline is None:
+            inline = utils.ipython_check() and (self.auth is None)
+        if inline:
+            if self.auth is not None:
+                print(
+                    "Warning: authentication is not supported inline. Please"
+                    "click the link to access the interface in a new tab."
+                )
+            try:
+                from IPython.display import HTML, Javascript, display  # type: ignore
+
+                if self.share and self.share_url:
+                    while not networking.url_ok(self.share_url):
+                        time.sleep(0.25)
+                    display(
+                        HTML(
+                            f'<div><iframe src="{self.share_url}" width="{self.width}" height="{self.height}" allow="autoplay; camera; microphone; clipboard-read; clipboard-write;" frameborder="0" allowfullscreen></iframe></div>'
+                        )
+                    )
+                elif self.is_colab:
+                    # modified from /usr/local/lib/python3.7/dist-packages/google/colab/output/_util.py within Colab environment
+                    code = """(async (port, path, width, height, cache, element) => {
+                        if (!google.colab.kernel.accessAllowed && !cache) {
+                            return;
+                        }
+                        element.appendChild(document.createTextNode(''));
+                        const url = await google.colab.kernel.proxyPort(port, {cache});
+
+                        const external_link = document.createElement('div');
+                        external_link.innerHTML = `
+                            <div style="font-family: monospace; margin-bottom: 0.5rem">
+                                Running on <a href=${new URL(path, url).toString()} target="_blank">
+                                    https://localhost:${port}${path}
+                                </a>
+                            </div>
+                        `;
+                        element.appendChild(external_link);
+
+                        const iframe = document.createElement('iframe');
+                        iframe.src = new URL(path, url).toString();
+                        iframe.height = height;
+                        iframe.allow = "autoplay; camera; microphone; clipboard-read; clipboard-write;"
+                        iframe.width = width;
+                        iframe.style.border = 0;
+                        element.appendChild(iframe);
+                    })""" + "({port}, {path}, {width}, {height}, {cache}, window.element)".format(
+                        port=json.dumps(self.server_port),
+                        path=json.dumps("/"),
+                        width=json.dumps(self.width),
+                        height=json.dumps(self.height),
+                        cache=json.dumps(False),
+                    )
+
+                    display(Javascript(code))
+                else:
+                    display(
+                        HTML(
+                            f'<div><iframe src="{self.local_url}" width="{self.width}" height="{self.height}" allow="autoplay; camera; microphone; clipboard-read; clipboard-write;" frameborder="0" allowfullscreen></iframe></div>'
+                        )
+                    )
+            except ImportError:
+                pass
+
+        if getattr(self, "analytics_enabled", False):
+            data = {
+                "launch_method": "browser" if inbrowser else "inline",
+                "is_google_colab": self.is_colab,
+                "is_sharing_on": self.share,
+                "share_url": self.share_url,
+                "enable_queue": self.enable_queue,
+                "show_tips": self.show_tips,
+                "server_name": server_name,
+                "server_port": server_port,
+                "is_spaces": self.is_space,
+                "mode": self.mode,
+            }
+            utils.launch_analytics(data)
+            utils.launched_telemetry(self, data)
+
+        utils.show_tip(self)
+
+        # Block main thread if debug==True
+        if debug or int(os.getenv("GRADIO_DEBUG", 0)) == 1:
+            self.block_thread()
+        # Block main thread if running in a script to stop script from exiting
+        is_in_interactive_mode = bool(getattr(sys, "ps1", sys.flags.interactive))
+
+        if not prevent_thread_lock and not is_in_interactive_mode:
+            self.block_thread()
+
+        return TupleNoPrint((self.server_app, self.local_url, self.share_url))
+
+    def integrate(
+        self,
+        comet_ml: comet_ml.Experiment | None = None,
+        wandb: ModuleType | None = None,
+        mlflow: ModuleType | None = None,
+    ) -> None:
+        """
+        A catch-all method for integrating with other libraries. This method should be run after launch()
+        Parameters:
+            comet_ml: If a comet_ml Experiment object is provided, will integrate with the experiment and appear on Comet dashboard
+            wandb: If the wandb module is provided, will integrate with it and appear on WandB dashboard
+            mlflow: If the mlflow module  is provided, will integrate with the experiment and appear on ML Flow dashboard
+        """
+        analytics_integration = ""
+        if comet_ml is not None:
+            analytics_integration = "CometML"
+            comet_ml.log_other("Created from", "Gradio")
+            if self.share_url is not None:
+                comet_ml.log_text("gradio: " + self.share_url)
+                comet_ml.end()
+            elif self.local_url:
+                comet_ml.log_text("gradio: " + self.local_url)
+                comet_ml.end()
+            else:
+                raise ValueError("Please run `launch()` first.")
+        if wandb is not None:
+            analytics_integration = "WandB"
+            if self.share_url is not None:
+                wandb.log(
+                    {
+                        "Gradio panel": wandb.Html(
+                            '<iframe src="'
+                            + self.share_url
+                            + '" width="'
+                            + str(self.width)
+                            + '" height="'
+                            + str(self.height)
+                            + '" frameBorder="0"></iframe>'
+                        )
+                    }
+                )
+            else:
+                print(
+                    "The WandB integration requires you to "
+                    "`launch(share=True)` first."
+                )
+        if mlflow is not None:
+            analytics_integration = "MLFlow"
+            if self.share_url is not None:
+                mlflow.log_param("Gradio Interface Share Link", self.share_url)
+            else:
+                mlflow.log_param("Gradio Interface Local Link", self.local_url)
+        if self.analytics_enabled and analytics_integration:
+            data = {"integration": analytics_integration}
+            utils.integration_analytics(data)
+
+    def close(self, verbose: bool = True) -> None:
+        """
+        Closes the Interface that was launched and frees the port.
+        """
+        try:
+            if self.enable_queue:
+                self._queue.close()
+            self.server.close()
+            self.is_running = False
+            # So that the startup events (starting the queue)
+            # happen the next time the app is launched
+            self.app.startup_events_triggered = False
+            if verbose:
+                print("Closing server running on port: {}".format(self.server_port))
+        except (AttributeError, OSError):  # can't close if not running
+            pass
+
+    def block_thread(
+        self,
+    ) -> None:
+        """Block main thread until interrupted by user."""
+        try:
+            while True:
+                time.sleep(0.1)
+        except (KeyboardInterrupt, OSError):
+            print("Keyboard interruption in main thread... closing server.")
+            self.server.close()
+            for tunnel in CURRENT_TUNNELS:
+                tunnel.kill()
+
+    def attach_load_events(self):
+        """Add a load event for every component whose initial value should be randomized."""
+        if Context.root_block:
+            for component in Context.root_block.blocks.values():
+                if (
+                    isinstance(component, components.IOComponent)
+                    and component.load_event_to_attach
+                ):
+                    load_fn, every = component.load_event_to_attach
+                    # Use set_event_trigger to avoid ambiguity between load class/instance method
+                    dep = self.set_event_trigger(
+                        "load",
+                        load_fn,
+                        None,
+                        component,
+                        no_target=True,
+                        # If every is None, for sure skip the queue
+                        # else, let the enable_queue parameter take precedence
+                        # this will raise a nice error message is every is used
+                        # without queue
+                        queue=False if every is None else None,
+                        every=every,
+                    )[0]
+                    component.load_event = dep
+
+    def startup_events(self):
+        """Events that should be run when the app containing this block starts up."""
+
+        if self.enable_queue:
+            utils.run_coro_in_background(self._queue.start, (self.progress_tracking,))
+            # So that processing can resume in case the queue was stopped
+            self._queue.stopped = False
+        utils.run_coro_in_background(self.create_limiter)
+
+    def queue_enabled_for_fn(self, fn_index: int):
+        if self.dependencies[fn_index]["queue"] is None:
+            return self.enable_queue
+        return self.dependencies[fn_index]["queue"]

gradio/context.py

@@ -0,0 +1,18 @@
+# Defines the Context class, which is used to store the state of all Blocks that are being rendered.
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:  # Only import for type checking (is False at runtime).
+    from gradio.blocks import BlockContext, Blocks
+
+
+class Context:
+    root_block: Blocks | None = None  # The current root block that holds all blocks.
+    block: BlockContext | None = None  # The current block that children are added to.
+    id: int = 0  # Running id to uniquely refer to any block that gets defined
+    ip_address: str | None = None  # The IP address of the user.
+    access_token: str | None = (
+        None  # The HF token that is provided when loading private models or Spaces
+    )

gradio/data_classes.py

@@ -0,0 +1,55 @@
+"""Pydantic data models and other dataclasses. This is the only file that uses Optional[]
+typing syntax instead of | None syntax to work with pydantic"""
+from enum import Enum, auto
+from typing import Any, Dict, List, Optional, Union
+
+from pydantic import BaseModel
+
+
+class PredictBody(BaseModel):
+    session_hash: Optional[str]
+    event_id: Optional[str]
+    data: List[Any]
+    event_data: Optional[Any]
+    fn_index: Optional[int]
+    batched: Optional[
+        bool
+    ] = False  # Whether the data is a batch of samples (i.e. called from the queue if batch=True) or a single sample (i.e. called from the UI)
+    request: Optional[
+        Union[Dict, List[Dict]]
+    ] = None  # dictionary of request headers, query parameters, url, etc. (used to to pass in request for queuing)
+
+
+class ResetBody(BaseModel):
+    session_hash: str
+    fn_index: int
+
+
+class InterfaceTypes(Enum):
+    STANDARD = auto()
+    INPUT_ONLY = auto()
+    OUTPUT_ONLY = auto()
+    UNIFIED = auto()
+
+
+class Estimation(BaseModel):
+    msg: Optional[str] = "estimation"
+    rank: Optional[int] = None
+    queue_size: int
+    avg_event_process_time: Optional[float]
+    avg_event_concurrent_process_time: Optional[float]
+    rank_eta: Optional[float] = None
+    queue_eta: float
+
+
+class ProgressUnit(BaseModel):
+    index: Optional[int]
+    length: Optional[int]
+    unit: Optional[str]
+    progress: Optional[float]
+    desc: Optional[str]
+
+
+class Progress(BaseModel):
+    msg: str = "progress"
+    progress_data: List[ProgressUnit] = []

gradio/deprecation.py

@@ -0,0 +1,45 @@
+import warnings
+
+
+def simple_deprecated_notice(term: str) -> str:
+    return f"`{term}` parameter is deprecated, and it has no effect"
+
+
+def use_in_launch(term: str) -> str:
+    return f"`{term}` is deprecated in `Interface()`, please use it within `launch()` instead."
+
+
+DEPRECATION_MESSAGE = {
+    "optional": simple_deprecated_notice("optional"),
+    "keep_filename": simple_deprecated_notice("keep_filename"),
+    "numeric": simple_deprecated_notice("numeric"),
+    "verbose": simple_deprecated_notice("verbose"),
+    "allow_screenshot": simple_deprecated_notice("allow_screenshot"),
+    "layout": simple_deprecated_notice("layout"),
+    "show_input": simple_deprecated_notice("show_input"),
+    "show_output": simple_deprecated_notice("show_output"),
+    "capture_session": simple_deprecated_notice("capture_session"),
+    "api_mode": simple_deprecated_notice("api_mode"),
+    "show_tips": use_in_launch("show_tips"),
+    "encrypt": simple_deprecated_notice("encrypt"),
+    "enable_queue": use_in_launch("enable_queue"),
+    "server_name": use_in_launch("server_name"),
+    "server_port": use_in_launch("server_port"),
+    "width": use_in_launch("width"),
+    "height": use_in_launch("height"),
+    "plot": "The 'plot' parameter has been deprecated. Use the new Plot component instead",
+    "type": "The 'type' parameter has been deprecated. Use the Number component instead.",
+}
+
+
+def check_deprecated_parameters(cls: str, **kwargs) -> None:
+    for key, value in DEPRECATION_MESSAGE.items():
+        if key in kwargs:
+            kwargs.pop(key)
+            # Interestingly, using DeprecationWarning causes warning to not appear.
+            warnings.warn(value)
+
+    if len(kwargs) != 0:
+        warnings.warn(
+            f"You have unused kwarg parameters in {cls}, please remove them: {kwargs}"
+        )

gradio/documentation.py

@@ -0,0 +1,261 @@
+"""Contains methods that generate documentation for Gradio functions and classes."""
+
+from __future__ import annotations
+
+import inspect
+from typing import Callable, Dict, List, Tuple
+
+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):
+        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
+            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 == "kwargs" 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 and "kwargs" in parameter_doc["doc"]:
+            parameter_doc["kwargs"] = 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

gradio/events.py

@@ -0,0 +1,298 @@
+"""Contains all of the events that can be triggered in a gr.Blocks() app, with the exception
+of the on-page-load event, which is defined in gr.Blocks().load()."""
+
+from __future__ import annotations
+
+import warnings
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Set, Tuple
+
+from gradio.blocks import Block
+from gradio.documentation import document, set_documentation_group
+from gradio.helpers import EventData
+from gradio.utils import get_cancel_function
+
+if TYPE_CHECKING:  # Only import for type checking (is False at runtime).
+    from gradio.components import Component, StatusTracker
+
+set_documentation_group("events")
+
+
+def set_cancel_events(
+    block: Block, event_name: str, cancels: None | Dict[str, Any] | List[Dict[str, Any]]
+):
+    if cancels:
+        if not isinstance(cancels, list):
+            cancels = [cancels]
+        cancel_fn, fn_indices_to_cancel = get_cancel_function(cancels)
+        block.set_event_trigger(
+            event_name,
+            cancel_fn,
+            inputs=None,
+            outputs=None,
+            queue=False,
+            preprocess=False,
+            cancels=fn_indices_to_cancel,
+        )
+
+
+class EventListener(Block):
+    def __init__(self: Any):
+        for event_listener_class in EventListener.__subclasses__():
+            if isinstance(self, event_listener_class):
+                event_listener_class.__init__(self)
+
+
+class Dependency(dict):
+    def __init__(self, trigger, key_vals, dep_index):
+        super().__init__(key_vals)
+        self.trigger = trigger
+        self.then = EventListenerMethod(
+            self.trigger,
+            "then",
+            trigger_after=dep_index,
+            trigger_only_on_success=False,
+        )
+        """
+        Triggered after directly preceding event is completed, regardless of success or failure.
+        """
+        self.success = EventListenerMethod(
+            self.trigger,
+            "success",
+            trigger_after=dep_index,
+            trigger_only_on_success=True,
+        )
+        """
+        Triggered after directly preceding event is completed, if it was successful.
+        """
+
+
+class EventListenerMethod:
+    """
+    Triggered on an event deployment.
+    """
+
+    def __init__(
+        self,
+        trigger: Block,
+        event_name: str,
+        show_progress: bool = True,
+        callback: Callable | None = None,
+        trigger_after: int | None = None,
+        trigger_only_on_success: bool = False,
+    ):
+        self.trigger = trigger
+        self.event_name = event_name
+        self.show_progress = show_progress
+        self.callback = callback
+        self.trigger_after = trigger_after
+        self.trigger_only_on_success = trigger_only_on_success
+
+    def __call__(
+        self,
+        fn: Callable | None,
+        inputs: Component | List[Component] | Set[Component] | None = None,
+        outputs: Component | List[Component] | None = None,
+        api_name: str | None = None,
+        status_tracker: StatusTracker | None = None,
+        scroll_to_output: bool = False,
+        show_progress: bool | None = None,
+        queue: bool | None = None,
+        batch: bool = False,
+        max_batch_size: int = 4,
+        preprocess: bool = True,
+        postprocess: bool = True,
+        cancels: Dict[str, Any] | List[Dict[str, Any]] | None = None,
+        every: float | None = None,
+        _js: str | None = None,
+    ) -> Dependency:
+        """
+        Parameters:
+            fn: the function to wrap an interface around. Often a machine learning model's prediction function. Each parameter of the function corresponds to one input component, and the function should return a single value or a tuple of values, with each element in the tuple corresponding to one output component.
+            inputs: List of gradio.components to use as inputs. If the function takes no inputs, this should be an empty list.
+            outputs: List of gradio.components to use as outputs. If the function returns no outputs, this should be an empty list.
+            api_name: Defining this parameter exposes the endpoint in the api docs
+            scroll_to_output: If True, will scroll to output component on completion
+            show_progress: If True, will show progress animation while pending
+            queue: If True, will place the request on the queue, if the queue exists
+            batch: If True, then the function should process a batch of inputs, meaning that it should accept a list of input values for each parameter. The lists should be of equal length (and be up to length `max_batch_size`). The function is then *required* to return a tuple of lists (even if there is only 1 output component), with each list in the tuple corresponding to one output component.
+            max_batch_size: Maximum number of inputs to batch together if this is called from the queue (only relevant if batch=True)
+            preprocess: If False, will not run preprocessing of component data before running 'fn' (e.g. leaving it as a base64 string if this method is called with the `Image` component).
+            postprocess: If False, will not run postprocessing of component data before returning 'fn' output to the browser.
+            cancels: A list of other events to cancel when this event is triggered. For example, setting cancels=[click_event] will cancel the click_event, where click_event is the return value of another components .click method.
+            every: Run this event 'every' number of seconds while the client connection is open. Interpreted in seconds. Queue must be enabled.
+        """
+        # _js: Optional frontend js method to run before running 'fn'. Input arguments for js method are values of 'inputs' and 'outputs', return should be a list of values for output components.
+        if status_tracker:
+            warnings.warn(
+                "The 'status_tracker' parameter has been deprecated and has no effect."
+            )
+        dep, dep_index = self.trigger.set_event_trigger(
+            self.event_name,
+            fn,
+            inputs,
+            outputs,
+            preprocess=preprocess,
+            postprocess=postprocess,
+            scroll_to_output=scroll_to_output,
+            show_progress=show_progress
+            if show_progress is not None
+            else self.show_progress,
+            api_name=api_name,
+            js=_js,
+            queue=queue,
+            batch=batch,
+            max_batch_size=max_batch_size,
+            every=every,
+            trigger_after=self.trigger_after,
+            trigger_only_on_success=self.trigger_only_on_success,
+        )
+        set_cancel_events(self.trigger, self.event_name, cancels)
+        if self.callback:
+            self.callback()
+        return Dependency(self.trigger, dep, dep_index)
+
+
+@document("*change", inherit=True)
+class Changeable(EventListener):
+    def __init__(self):
+        self.change = EventListenerMethod(self, "change")
+        """
+        This event is triggered when the component's input value changes (e.g. when the user types in a textbox
+        or uploads an image). This method can be used when this component is in a Gradio Blocks.
+        """
+
+
+@document("*click", inherit=True)
+class Clickable(EventListener):
+    def __init__(self):
+        self.click = EventListenerMethod(self, "click")
+        """
+        This event is triggered when the component (e.g. a button) is clicked.
+        This method can be used when this component is in a Gradio Blocks.
+        """
+
+
+@document("*submit", inherit=True)
+class Submittable(EventListener):
+    def __init__(self):
+        self.submit = EventListenerMethod(self, "submit")
+        """
+        This event is triggered when the user presses the Enter key while the component (e.g. a textbox) is focused.
+        This method can be used when this component is in a Gradio Blocks.
+        """
+
+
+@document("*edit", inherit=True)
+class Editable(EventListener):
+    def __init__(self):
+        self.edit = EventListenerMethod(self, "edit")
+        """
+        This event is triggered when the user edits the component (e.g. image) using the
+        built-in editor. This method can be used when this component is in a Gradio Blocks.
+        """
+
+
+@document("*clear", inherit=True)
+class Clearable(EventListener):
+    def __init__(self):
+        self.clear = EventListenerMethod(self, "clear")
+        """
+        This event is triggered when the user clears the component (e.g. image or audio)
+        using the X button for the component. This method can be used when this component is in a Gradio Blocks.
+        """
+
+
+@document("*play", "*pause", "*stop", inherit=True)
+class Playable(EventListener):
+    def __init__(self):
+        self.play = EventListenerMethod(self, "play")
+        """
+        This event is triggered when the user plays the component (e.g. audio or video).
+        This method can be used when this component is in a Gradio Blocks.
+        """
+
+        self.pause = EventListenerMethod(self, "pause")
+        """
+        This event is triggered when the user pauses the component (e.g. audio or video).
+        This method can be used when this component is in a Gradio Blocks.
+        """
+
+        self.stop = EventListenerMethod(self, "stop")
+        """
+        This event is triggered when the user stops the component (e.g. audio or video).
+        This method can be used when this component is in a Gradio Blocks.
+        """
+
+
+@document("*stream", inherit=True)
+class Streamable(EventListener):
+    def __init__(self):
+        self.streaming: bool
+        self.stream = EventListenerMethod(
+            self,
+            "stream",
+            show_progress=False,
+            callback=lambda: setattr(self, "streaming", True),
+        )
+        """
+        This event is triggered when the user streams the component (e.g. a live webcam
+        component). This method can be used when this component is in a Gradio Blocks.
+        """
+
+
+@document("*blur", inherit=True)
+class Blurrable(EventListener):
+    def __init__(self):
+        self.blur = EventListenerMethod(self, "blur")
+        """
+        This event is triggered when the component's is unfocused/blurred (e.g. when the user clicks outside of a textbox). This method can be used when this component is in a Gradio Blocks.
+        """
+
+
+@document("*upload", inherit=True)
+class Uploadable(EventListener):
+    def __init__(self):
+        self.upload = EventListenerMethod(self, "upload")
+        """
+        This event is triggered when the user uploads a file into the component (e.g. when the user uploads a video into a video component). This method can be used when this component is in a Gradio Blocks.
+        """
+
+
+@document("*release", inherit=True)
+class Releaseable(EventListener):
+    def __init__(self):
+        self.release = EventListenerMethod(self, "release")
+        """
+        This event is triggered when the user releases the mouse on this component (e.g. when the user releases the slider). This method can be used when this component is in a Gradio Blocks.
+        """
+
+
+@document("*select", inherit=True)
+class Selectable(EventListener):
+    def __init__(self):
+        self.selectable: bool = False
+        self.select = EventListenerMethod(
+            self, "select", callback=lambda: setattr(self, "selectable", True)
+        )
+        """
+        This event is triggered when the user selects from within the Component.
+        This event has EventData of type gradio.SelectData that carries information, accessible through SelectData.index and SelectData.value.
+        See EventData documentation on how to use this event data.
+        """
+
+
+class SelectData(EventData):
+    def __init__(self, target: Block | None, data: Any):
+        super().__init__(target, data)
+        self.index: int | Tuple[int, int] = data["index"]
+        """
+        The index of the selected item. Is a tuple if the component is two dimensional or selection is a range.
+        """
+        self.value: Any = data["value"]
+        """
+        The value of the selected item.
+        """
+        self.selected: bool = data.get("selected", True)
+        """
+        True if the item was selected, False if deselected.
+        """

gradio/exceptions.py

@@ -0,0 +1,39 @@
+from gradio.documentation import document, set_documentation_group
+
+set_documentation_group("helpers")
+
+
+class DuplicateBlockError(ValueError):
+    """Raised when a Blocks contains more than one Block with the same id"""
+
+    pass
+
+
+class TooManyRequestsError(Exception):
+    """Raised when the Hugging Face API returns a 429 status code."""
+
+    pass
+
+
+class InvalidApiName(ValueError):
+    pass
+
+
+@document()
+class Error(Exception):
+    """
+    This class allows you to pass custom error messages to the user. You can do so by raising a gr.Error("custom message") anywhere in the code, and when that line is executed the custom message will appear in a modal on the demo.
+
+    Demos: calculator
+    """
+
+    def __init__(self, message: str):
+        """
+        Parameters:
+            message: The error message to be displayed to the user.
+        """
+        self.message = message
+        super().__init__(self.message)
+
+    def __str__(self):
+        return repr(self.message)

gradio/external.py

@@ -0,0 +1,512 @@
+"""This module should not be used directly as its API is subject to change. Instead,
+use the `gr.Blocks.load()` or `gr.Interface.load()` functions."""
+
+from __future__ import annotations
+
+import json
+import re
+import uuid
+import warnings
+from copy import deepcopy
+from typing import TYPE_CHECKING, Callable, Dict
+
+import requests
+
+import gradio
+from gradio import components, utils
+from gradio.context import Context
+from gradio.exceptions import Error, TooManyRequestsError
+from gradio.external_utils import (
+    cols_to_rows,
+    encode_to_base64,
+    get_tabular_examples,
+    get_ws_fn,
+    postprocess_label,
+    rows_to_cols,
+    streamline_spaces_interface,
+    use_websocket,
+)
+from gradio.processing_utils import to_binary
+
+if TYPE_CHECKING:
+    from gradio.blocks import Blocks
+    from gradio.interface import Interface
+
+
+def load_blocks_from_repo(
+    name: str,
+    src: str | None = None,
+    api_key: str | None = None,
+    alias: str | None = None,
+    **kwargs,
+) -> Blocks:
+    """Creates and returns a Blocks instance from a Hugging Face model or Space repo."""
+    if src is None:
+        # Separate the repo type (e.g. "model") from repo name (e.g. "google/vit-base-patch16-224")
+        tokens = name.split("/")
+        assert (
+            len(tokens) > 1
+        ), "Either `src` parameter must be provided, or `name` must be formatted as {src}/{repo name}"
+        src = tokens[0]
+        name = "/".join(tokens[1:])
+
+    factory_methods: Dict[str, Callable] = {
+        # for each repo type, we have a method that returns the Interface given the model name & optionally an api_key
+        "huggingface": from_model,
+        "models": from_model,
+        "spaces": from_spaces,
+    }
+    assert src.lower() in factory_methods, "parameter: src must be one of {}".format(
+        factory_methods.keys()
+    )
+
+    if api_key is not None:
+        if Context.access_token is not None and Context.access_token != api_key:
+            warnings.warn(
+                """You are loading a model/Space with a different access token than the one you used to load a previous model/Space. This is not recommended, as it may cause unexpected behavior."""
+            )
+        Context.access_token = api_key
+
+    blocks: gradio.Blocks = factory_methods[src](name, api_key, alias, **kwargs)
+    return blocks
+
+
+def chatbot_preprocess(text, state):
+    payload = {
+        "inputs": {"generated_responses": None, "past_user_inputs": None, "text": text}
+    }
+    if state is not None:
+        payload["inputs"]["generated_responses"] = state["conversation"][
+            "generated_responses"
+        ]
+        payload["inputs"]["past_user_inputs"] = state["conversation"][
+            "past_user_inputs"
+        ]
+
+    return payload
+
+
+def chatbot_postprocess(response):
+    response_json = response.json()
+    chatbot_value = list(
+        zip(
+            response_json["conversation"]["past_user_inputs"],
+            response_json["conversation"]["generated_responses"],
+        )
+    )
+    return chatbot_value, response_json
+
+
+def from_model(model_name: str, api_key: str | None, alias: str | None, **kwargs):
+    model_url = "https://huggingface.co/{}".format(model_name)
+    api_url = "https://api-inference.huggingface.co/models/{}".format(model_name)
+    print("Fetching model from: {}".format(model_url))
+
+    headers = {"Authorization": f"Bearer {api_key}"} if api_key is not None else {}
+
+    # Checking if model exists, and if so, it gets the pipeline
+    response = requests.request("GET", api_url, headers=headers)
+    assert (
+        response.status_code == 200
+    ), f"Could not find model: {model_name}. If it is a private or gated model, please provide your Hugging Face access token (https://huggingface.co/settings/tokens) as the argument for the `api_key` parameter."
+    p = response.json().get("pipeline_tag")
+    pipelines = {
+        "audio-classification": {
+            # example model: ehcalabres/wav2vec2-lg-xlsr-en-speech-emotion-recognition
+            "inputs": components.Audio(source="upload", type="filepath", label="Input"),
+            "outputs": components.Label(label="Class"),
+            "preprocess": lambda i: to_binary,
+            "postprocess": lambda r: postprocess_label(
+                {i["label"].split(", ")[0]: i["score"] for i in r.json()}
+            ),
+        },
+        "audio-to-audio": {
+            # example model: facebook/xm_transformer_sm_all-en
+            "inputs": components.Audio(source="upload", type="filepath", label="Input"),
+            "outputs": components.Audio(label="Output"),
+            "preprocess": to_binary,
+            "postprocess": encode_to_base64,
+        },
+        "automatic-speech-recognition": {
+            # example model: facebook/wav2vec2-base-960h
+            "inputs": components.Audio(source="upload", type="filepath", label="Input"),
+            "outputs": components.Textbox(label="Output"),
+            "preprocess": to_binary,
+            "postprocess": lambda r: r.json()["text"],
+        },
+        "conversational": {
+            "inputs": [components.Textbox(), components.State()],  # type: ignore
+            "outputs": [components.Chatbot(), components.State()],  # type: ignore
+            "preprocess": chatbot_preprocess,
+            "postprocess": chatbot_postprocess,
+        },
+        "feature-extraction": {
+            # example model: julien-c/distilbert-feature-extraction
+            "inputs": components.Textbox(label="Input"),
+            "outputs": components.Dataframe(label="Output"),
+            "preprocess": lambda x: {"inputs": x},
+            "postprocess": lambda r: r.json()[0],
+        },
+        "fill-mask": {
+            "inputs": components.Textbox(label="Input"),
+            "outputs": components.Label(label="Classification"),
+            "preprocess": lambda x: {"inputs": x},
+            "postprocess": lambda r: postprocess_label(
+                {i["token_str"]: i["score"] for i in r.json()}
+            ),
+        },
+        "image-classification": {
+            # Example: google/vit-base-patch16-224
+            "inputs": components.Image(type="filepath", label="Input Image"),
+            "outputs": components.Label(label="Classification"),
+            "preprocess": to_binary,
+            "postprocess": lambda r: postprocess_label(
+                {i["label"].split(", ")[0]: i["score"] for i in r.json()}
+            ),
+        },
+        "image-to-text": {
+            "inputs": components.Image(type="filepath", label="Input Image"),
+            "outputs": components.Textbox(),
+            "preprocess": to_binary,
+            "postprocess": lambda r: r.json()[0]["generated_text"],
+        },
+        "question-answering": {
+            # Example: deepset/xlm-roberta-base-squad2
+            "inputs": [
+                components.Textbox(lines=7, label="Context"),
+                components.Textbox(label="Question"),
+            ],
+            "outputs": [
+                components.Textbox(label="Answer"),
+                components.Label(label="Score"),
+            ],
+            "preprocess": lambda c, q: {"inputs": {"context": c, "question": q}},
+            "postprocess": lambda r: (r.json()["answer"], {"label": r.json()["score"]}),
+        },
+        "summarization": {
+            # Example: facebook/bart-large-cnn
+            "inputs": components.Textbox(label="Input"),
+            "outputs": components.Textbox(label="Summary"),
+            "preprocess": lambda x: {"inputs": x},
+            "postprocess": lambda r: r.json()[0]["summary_text"],
+        },
+        "text-classification": {
+            # Example: distilbert-base-uncased-finetuned-sst-2-english
+            "inputs": components.Textbox(label="Input"),
+            "outputs": components.Label(label="Classification"),
+            "preprocess": lambda x: {"inputs": x},
+            "postprocess": lambda r: postprocess_label(
+                {i["label"].split(", ")[0]: i["score"] for i in r.json()[0]}
+            ),
+        },
+        "text-generation": {
+            # Example: gpt2
+            "inputs": components.Textbox(label="Input"),
+            "outputs": components.Textbox(label="Output"),
+            "preprocess": lambda x: {"inputs": x},
+            "postprocess": lambda r: r.json()[0]["generated_text"],
+        },
+        "text2text-generation": {
+            # Example: valhalla/t5-small-qa-qg-hl
+            "inputs": components.Textbox(label="Input"),
+            "outputs": components.Textbox(label="Generated Text"),
+            "preprocess": lambda x: {"inputs": x},
+            "postprocess": lambda r: r.json()[0]["generated_text"],
+        },
+        "translation": {
+            "inputs": components.Textbox(label="Input"),
+            "outputs": components.Textbox(label="Translation"),
+            "preprocess": lambda x: {"inputs": x},
+            "postprocess": lambda r: r.json()[0]["translation_text"],
+        },
+        "zero-shot-classification": {
+            # Example: facebook/bart-large-mnli
+            "inputs": [
+                components.Textbox(label="Input"),
+                components.Textbox(label="Possible class names (" "comma-separated)"),
+                components.Checkbox(label="Allow multiple true classes"),
+            ],
+            "outputs": components.Label(label="Classification"),
+            "preprocess": lambda i, c, m: {
+                "inputs": i,
+                "parameters": {"candidate_labels": c, "multi_class": m},
+            },
+            "postprocess": lambda r: postprocess_label(
+                {
+                    r.json()["labels"][i]: r.json()["scores"][i]
+                    for i in range(len(r.json()["labels"]))
+                }
+            ),
+        },
+        "sentence-similarity": {
+            # Example: sentence-transformers/distilbert-base-nli-stsb-mean-tokens
+            "inputs": [
+                components.Textbox(
+                    value="That is a happy person", label="Source Sentence"
+                ),
+                components.Textbox(
+                    lines=7,
+                    placeholder="Separate each sentence by a newline",
+                    label="Sentences to compare to",
+                ),
+            ],
+            "outputs": components.Label(label="Classification"),
+            "preprocess": lambda src, sentences: {
+                "inputs": {
+                    "source_sentence": src,
+                    "sentences": [s for s in sentences.splitlines() if s != ""],
+                }
+            },
+            "postprocess": lambda r: postprocess_label(
+                {f"sentence {i}": v for i, v in enumerate(r.json())}
+            ),
+        },
+        "text-to-speech": {
+            # Example: julien-c/ljspeech_tts_train_tacotron2_raw_phn_tacotron_g2p_en_no_space_train
+            "inputs": components.Textbox(label="Input"),
+            "outputs": components.Audio(label="Audio"),
+            "preprocess": lambda x: {"inputs": x},
+            "postprocess": encode_to_base64,
+        },
+        "text-to-image": {
+            # example model: osanseviero/BigGAN-deep-128
+            "inputs": components.Textbox(label="Input"),
+            "outputs": components.Image(label="Output"),
+            "preprocess": lambda x: {"inputs": x},
+            "postprocess": encode_to_base64,
+        },
+        "token-classification": {
+            # example model: huggingface-course/bert-finetuned-ner
+            "inputs": components.Textbox(label="Input"),
+            "outputs": components.HighlightedText(label="Output"),
+            "preprocess": lambda x: {"inputs": x},
+            "postprocess": lambda r: r,  # Handled as a special case in query_huggingface_api()
+        },
+    }
+
+    if p in ["tabular-classification", "tabular-regression"]:
+        example_data = get_tabular_examples(model_name)
+        col_names, example_data = cols_to_rows(example_data)
+        example_data = [[example_data]] if example_data else None
+
+        pipelines[p] = {
+            "inputs": components.Dataframe(
+                label="Input Rows",
+                type="pandas",
+                headers=col_names,
+                col_count=(len(col_names), "fixed"),
+            ),
+            "outputs": components.Dataframe(
+                label="Predictions", type="array", headers=["prediction"]
+            ),
+            "preprocess": rows_to_cols,
+            "postprocess": lambda r: {
+                "headers": ["prediction"],
+                "data": [[pred] for pred in json.loads(r.text)],
+            },
+            "examples": example_data,
+        }
+
+    if p is None or not (p in pipelines):
+        raise ValueError("Unsupported pipeline type: {}".format(p))
+
+    pipeline = pipelines[p]
+
+    def query_huggingface_api(*params):
+        # Convert to a list of input components
+        data = pipeline["preprocess"](*params)
+        if isinstance(
+            data, dict
+        ):  # HF doesn't allow additional parameters for binary files (e.g. images or audio files)
+            data.update({"options": {"wait_for_model": True}})
+            data = json.dumps(data)
+        response = requests.request("POST", api_url, headers=headers, data=data)
+        if not (response.status_code == 200):
+            errors_json = response.json()
+            errors, warns = "", ""
+            if errors_json.get("error"):
+                errors = f", Error: {errors_json.get('error')}"
+            if errors_json.get("warnings"):
+                warns = f", Warnings: {errors_json.get('warnings')}"
+            raise Error(
+                f"Could not complete request to HuggingFace API, Status Code: {response.status_code}"
+                + errors
+                + warns
+            )
+        if (
+            p == "token-classification"
+        ):  # Handle as a special case since HF API only returns the named entities and we need the input as well
+            ner_groups = response.json()
+            input_string = params[0]
+            response = utils.format_ner_list(input_string, ner_groups)
+        output = pipeline["postprocess"](response)
+        return output
+
+    if alias is None:
+        query_huggingface_api.__name__ = model_name
+    else:
+        query_huggingface_api.__name__ = alias
+
+    interface_info = {
+        "fn": query_huggingface_api,
+        "inputs": pipeline["inputs"],
+        "outputs": pipeline["outputs"],
+        "title": model_name,
+        "examples": pipeline.get("examples"),
+    }
+
+    kwargs = dict(interface_info, **kwargs)
+
+    # So interface doesn't run pre/postprocess
+    # except for conversational interfaces which
+    # are stateful
+    kwargs["_api_mode"] = p != "conversational"
+
+    interface = gradio.Interface(**kwargs)
+    return interface
+
+
+def from_spaces(
+    space_name: str, api_key: str | None, alias: str | None, **kwargs
+) -> Blocks:
+    space_url = "https://huggingface.co/spaces/{}".format(space_name)
+
+    print("Fetching Space from: {}".format(space_url))
+
+    headers = {}
+    if api_key is not None:
+        headers["Authorization"] = f"Bearer {api_key}"
+
+    iframe_url = (
+        requests.get(
+            f"https://huggingface.co/api/spaces/{space_name}/host", headers=headers
+        )
+        .json()
+        .get("host")
+    )
+
+    if iframe_url is None:
+        raise ValueError(
+            f"Could not find Space: {space_name}. If it is a private or gated Space, please provide your Hugging Face access token (https://huggingface.co/settings/tokens) as the argument for the `api_key` parameter."
+        )
+
+    r = requests.get(iframe_url, headers=headers)
+
+    result = re.search(
+        r"window.gradio_config = (.*?);[\s]*</script>", r.text
+    )  # some basic regex to extract the config
+    try:
+        config = json.loads(result.group(1))  # type: ignore
+    except AttributeError:
+        raise ValueError("Could not load the Space: {}".format(space_name))
+    if "allow_flagging" in config:  # Create an Interface for Gradio 2.x Spaces
+        return from_spaces_interface(
+            space_name, config, alias, api_key, iframe_url, **kwargs
+        )
+    else:  # Create a Blocks for Gradio 3.x Spaces
+        if kwargs:
+            warnings.warn(
+                "You cannot override parameters for this Space by passing in kwargs. "
+                "Instead, please load the Space as a function and use it to create a "
+                "Blocks or Interface locally. You may find this Guide helpful: "
+                "https://gradio.app/using_blocks_like_functions/"
+            )
+        return from_spaces_blocks(config, api_key, iframe_url)
+
+
+def from_spaces_blocks(config: Dict, api_key: str | None, iframe_url: str) -> Blocks:
+    api_url = "{}/api/predict/".format(iframe_url)
+
+    headers = {"Content-Type": "application/json"}
+    if api_key is not None:
+        headers["Authorization"] = f"Bearer {api_key}"
+    ws_url = "{}/queue/join".format(iframe_url).replace("https", "wss")
+
+    ws_fn = get_ws_fn(ws_url, headers)
+
+    fns = []
+    for d, dependency in enumerate(config["dependencies"]):
+        if dependency["backend_fn"]:
+
+            def get_fn(outputs, fn_index, use_ws):
+                def fn(*data):
+                    data = json.dumps({"data": data, "fn_index": fn_index})
+                    hash_data = json.dumps(
+                        {"fn_index": fn_index, "session_hash": str(uuid.uuid4())}
+                    )
+                    if use_ws:
+                        result = utils.synchronize_async(ws_fn, data, hash_data)
+                        output = result["data"]
+                    else:
+                        response = requests.post(api_url, headers=headers, data=data)
+                        result = json.loads(response.content.decode("utf-8"))
+                        try:
+                            output = result["data"]
+                        except KeyError:
+                            if "error" in result and "429" in result["error"]:
+                                raise TooManyRequestsError(
+                                    "Too many requests to the Hugging Face API"
+                                )
+                            raise KeyError(
+                                f"Could not find 'data' key in response from external Space. Response received: {result}"
+                            )
+                    if len(outputs) == 1:
+                        output = output[0]
+                    return output
+
+                return fn
+
+            fn = get_fn(
+                deepcopy(dependency["outputs"]), d, use_websocket(config, dependency)
+            )
+            fns.append(fn)
+        else:
+            fns.append(None)
+    return gradio.Blocks.from_config(config, fns, iframe_url)
+
+
+def from_spaces_interface(
+    model_name: str,
+    config: Dict,
+    alias: str | None,
+    api_key: str | None,
+    iframe_url: str,
+    **kwargs,
+) -> Interface:
+
+    config = streamline_spaces_interface(config)
+    api_url = "{}/api/predict/".format(iframe_url)
+    headers = {"Content-Type": "application/json"}
+    if api_key is not None:
+        headers["Authorization"] = f"Bearer {api_key}"
+
+    # The function should call the API with preprocessed data
+    def fn(*data):
+        data = json.dumps({"data": data})
+        response = requests.post(api_url, headers=headers, data=data)
+        result = json.loads(response.content.decode("utf-8"))
+        try:
+            output = result["data"]
+        except KeyError:
+            if "error" in result and "429" in result["error"]:
+                raise TooManyRequestsError("Too many requests to the Hugging Face API")
+            raise KeyError(
+                f"Could not find 'data' key in response from external Space. Response received: {result}"
+            )
+        if (
+            len(config["outputs"]) == 1
+        ):  # if the fn is supposed to return a single value, pop it
+            output = output[0]
+        if len(config["outputs"]) == 1 and isinstance(
+            output, list
+        ):  # Needed to support Output.Image() returning bounding boxes as well (TODO: handle different versions of gradio since they have slightly different APIs)
+            output = output[0]
+        return output
+
+    fn.__name__ = alias if (alias is not None) else model_name
+    config["fn"] = fn
+
+    kwargs = dict(config, **kwargs)
+    kwargs["_api_mode"] = True
+    interface = gradio.Interface(**kwargs)
+    return interface

gradio/external_utils.py

@@ -0,0 +1,185 @@
+"""Utility function for gradio/external.py"""
+
+import base64
+import json
+import math
+import operator
+import re
+import warnings
+from typing import Any, Dict, List, Tuple
+
+import requests
+import websockets
+import yaml
+from packaging import version
+from websockets.legacy.protocol import WebSocketCommonProtocol
+
+from gradio import components, exceptions
+
+##################
+# Helper functions for processing tabular data
+##################
+
+
+def get_tabular_examples(model_name: str) -> Dict[str, List[float]]:
+    readme = requests.get(f"https://huggingface.co/{model_name}/resolve/main/README.md")
+    if readme.status_code != 200:
+        warnings.warn(f"Cannot load examples from README for {model_name}", UserWarning)
+        example_data = {}
+    else:
+        yaml_regex = re.search(
+            "(?:^|[\r\n])---[\n\r]+([\\S\\s]*?)[\n\r]+---([\n\r]|$)", readme.text
+        )
+        if yaml_regex is None:
+            example_data = {}
+        else:
+            example_yaml = next(
+                yaml.safe_load_all(readme.text[: yaml_regex.span()[-1]])
+            )
+            example_data = example_yaml.get("widget", {}).get("structuredData", {})
+    if not example_data:
+        raise ValueError(
+            f"No example data found in README.md of {model_name} - Cannot build gradio demo. "
+            "See the README.md here: https://huggingface.co/scikit-learn/tabular-playground/blob/main/README.md "
+            "for a reference on how to provide example data to your model."
+        )
+    # replace nan with string NaN for inference API
+    for data in example_data.values():
+        for i, val in enumerate(data):
+            if isinstance(val, float) and math.isnan(val):
+                data[i] = "NaN"
+    return example_data
+
+
+def cols_to_rows(
+    example_data: Dict[str, List[float]]
+) -> Tuple[List[str], List[List[float]]]:
+    headers = list(example_data.keys())
+    n_rows = max(len(example_data[header] or []) for header in headers)
+    data = []
+    for row_index in range(n_rows):
+        row_data = []
+        for header in headers:
+            col = example_data[header] or []
+            if row_index >= len(col):
+                row_data.append("NaN")
+            else:
+                row_data.append(col[row_index])
+        data.append(row_data)
+    return headers, data
+
+
+def rows_to_cols(incoming_data: Dict) -> Dict[str, Dict[str, Dict[str, List[str]]]]:
+    data_column_wise = {}
+    for i, header in enumerate(incoming_data["headers"]):
+        data_column_wise[header] = [str(row[i]) for row in incoming_data["data"]]
+    return {"inputs": {"data": data_column_wise}}
+
+
+##################
+# Helper functions for processing other kinds of data
+##################
+
+
+def postprocess_label(scores: Dict) -> Dict:
+    sorted_pred = sorted(scores.items(), key=operator.itemgetter(1), reverse=True)
+    return {
+        "label": sorted_pred[0][0],
+        "confidences": [
+            {"label": pred[0], "confidence": pred[1]} for pred in sorted_pred
+        ],
+    }
+
+
+def encode_to_base64(r: requests.Response) -> str:
+    # Handles the different ways HF API returns the prediction
+    base64_repr = base64.b64encode(r.content).decode("utf-8")
+    data_prefix = ";base64,"
+    # Case 1: base64 representation already includes data prefix
+    if data_prefix in base64_repr:
+        return base64_repr
+    else:
+        content_type = r.headers.get("content-type")
+        # Case 2: the data prefix is a key in the response
+        if content_type == "application/json":
+            try:
+                content_type = r.json()[0]["content-type"]
+                base64_repr = r.json()[0]["blob"]
+            except KeyError:
+                raise ValueError(
+                    "Cannot determine content type returned" "by external API."
+                )
+        # Case 3: the data prefix is included in the response headers
+        else:
+            pass
+        new_base64 = "data:{};base64,".format(content_type) + base64_repr
+        return new_base64
+
+
+##################
+# Helper functions for connecting to websockets
+##################
+
+
+async def get_pred_from_ws(
+    websocket: WebSocketCommonProtocol, data: str, hash_data: str
+) -> Dict[str, Any]:
+    completed = False
+    resp = {}
+    while not completed:
+        msg = await websocket.recv()
+        resp = json.loads(msg)
+        if resp["msg"] == "queue_full":
+            raise exceptions.Error("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"]
+
+
+def get_ws_fn(ws_url, headers):
+    async def ws_fn(data, hash_data):
+        async with websockets.connect(  # type: ignore
+            ws_url, open_timeout=10, extra_headers=headers
+        ) as websocket:
+            return await get_pred_from_ws(websocket, data, hash_data)
+
+    return ws_fn
+
+
+def use_websocket(config, dependency):
+    queue_enabled = config.get("enable_queue", False)
+    queue_uses_websocket = version.parse(
+        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
+
+
+##################
+# Helper function for cleaning up an Interface loaded from HF Spaces
+##################
+
+
+def streamline_spaces_interface(config: Dict) -> Dict:
+    """Streamlines the interface config dictionary to remove unnecessary keys."""
+    config["inputs"] = [
+        components.get_component_instance(component)
+        for component in config["input_components"]
+    ]
+    config["outputs"] = [
+        components.get_component_instance(component)
+        for component in config["output_components"]
+    ]
+    parameters = {
+        "article",
+        "description",
+        "flagging_options",
+        "inputs",
+        "outputs",
+        "title",
+    }
+    config = {k: config[k] for k in parameters}
+    return config

gradio/flagging.py

@@ -0,0 +1,555 @@
+from __future__ import annotations
+
+import csv
+import datetime
+import json
+import os
+import time
+import uuid
+from abc import ABC, abstractmethod
+from distutils.version import StrictVersion
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, List
+
+import pkg_resources
+
+import gradio as gr
+from gradio import utils
+from gradio.documentation import document, set_documentation_group
+
+if TYPE_CHECKING:
+    from gradio.components import IOComponent
+
+set_documentation_group("flagging")
+
+
+def _get_dataset_features_info(is_new, components):
+    """
+    Takes in a list of components and returns a dataset features info
+
+    Parameters:
+    is_new: boolean, whether the dataset is new or not
+    components: list of components
+
+    Returns:
+    infos: a dictionary of the dataset features
+    file_preview_types: dictionary mapping of gradio components to appropriate string.
+    header: list of header strings
+
+    """
+    infos = {"flagged": {"features": {}}}
+    # File previews for certain input and output types
+    file_preview_types = {gr.Audio: "Audio", gr.Image: "Image"}
+    headers = []
+
+    # Generate the headers and dataset_infos
+    if is_new:
+
+        for component in components:
+            headers.append(component.label)
+            infos["flagged"]["features"][component.label] = {
+                "dtype": "string",
+                "_type": "Value",
+            }
+            if isinstance(component, tuple(file_preview_types)):
+                headers.append(component.label + " file")
+                for _component, _type in file_preview_types.items():
+                    if isinstance(component, _component):
+                        infos["flagged"]["features"][
+                            (component.label or "") + " file"
+                        ] = {"_type": _type}
+                        break
+
+        headers.append("flag")
+        infos["flagged"]["features"]["flag"] = {
+            "dtype": "string",
+            "_type": "Value",
+        }
+
+    return infos, file_preview_types, headers
+
+
+class FlaggingCallback(ABC):
+    """
+    An abstract class for defining the methods that any FlaggingCallback should have.
+    """
+
+    @abstractmethod
+    def setup(self, components: List[IOComponent], flagging_dir: str):
+        """
+        This method should be overridden and ensure that everything is set up correctly for flag().
+        This method gets called once at the beginning of the Interface.launch() method.
+        Parameters:
+        components: Set of components that will provide flagged data.
+        flagging_dir: A string, typically containing the path to the directory where the flagging file should be storied (provided as an argument to Interface.__init__()).
+        """
+        pass
+
+    @abstractmethod
+    def flag(
+        self,
+        flag_data: List[Any],
+        flag_option: str = "",
+        username: str | None = None,
+    ) -> int:
+        """
+        This method should be overridden by the FlaggingCallback subclass and may contain optional additional arguments.
+        This gets called every time the <flag> button is pressed.
+        Parameters:
+        interface: The Interface object that is being used to launch the flagging interface.
+        flag_data: The data to be flagged.
+        flag_option (optional): In the case that flagging_options are provided, the flag option that is being used.
+        username (optional): The username of the user that is flagging the data, if logged in.
+        Returns:
+        (int) The total number of samples that have been flagged.
+        """
+        pass
+
+
+@document()
+class SimpleCSVLogger(FlaggingCallback):
+    """
+    A simplified implementation of the FlaggingCallback abstract class
+    provided for illustrative purposes.  Each flagged sample (both the input and output data)
+    is logged to a CSV file on the machine running the gradio app.
+    Example:
+        import gradio as gr
+        def image_classifier(inp):
+            return {'cat': 0.3, 'dog': 0.7}
+        demo = gr.Interface(fn=image_classifier, inputs="image", outputs="label",
+                            flagging_callback=SimpleCSVLogger())
+    """
+
+    def __init__(self):
+        pass
+
+    def setup(self, components: List[IOComponent], flagging_dir: str | Path):
+        self.components = components
+        self.flagging_dir = flagging_dir
+        os.makedirs(flagging_dir, exist_ok=True)
+
+    def flag(
+        self,
+        flag_data: List[Any],
+        flag_option: str = "",
+        username: str | None = None,
+    ) -> int:
+        flagging_dir = self.flagging_dir
+        log_filepath = Path(flagging_dir) / "log.csv"
+
+        csv_data = []
+        for component, sample in zip(self.components, flag_data):
+            save_dir = Path(flagging_dir) / utils.strip_invalid_filename_characters(
+                component.label or ""
+            )
+            csv_data.append(
+                component.deserialize(
+                    sample,
+                    save_dir,
+                    None,
+                )
+            )
+
+        with open(log_filepath, "a", newline="") as csvfile:
+            writer = csv.writer(csvfile)
+            writer.writerow(utils.sanitize_list_for_csv(csv_data))
+
+        with open(log_filepath, "r") as csvfile:
+            line_count = len([None for row in csv.reader(csvfile)]) - 1
+        return line_count
+
+
+@document()
+class CSVLogger(FlaggingCallback):
+    """
+    The default implementation of the FlaggingCallback abstract class. Each flagged
+    sample (both the input and output data) is logged to a CSV file with headers on the machine running the gradio app.
+    Example:
+        import gradio as gr
+        def image_classifier(inp):
+            return {'cat': 0.3, 'dog': 0.7}
+        demo = gr.Interface(fn=image_classifier, inputs="image", outputs="label",
+                            flagging_callback=CSVLogger())
+    Guides: using_flagging
+    """
+
+    def __init__(self):
+        pass
+
+    def setup(
+        self,
+        components: List[IOComponent],
+        flagging_dir: str | Path,
+    ):
+        self.components = components
+        self.flagging_dir = flagging_dir
+        os.makedirs(flagging_dir, exist_ok=True)
+
+    def flag(
+        self,
+        flag_data: List[Any],
+        flag_option: str = "",
+        username: str | None = None,
+    ) -> int:
+        flagging_dir = self.flagging_dir
+        log_filepath = Path(flagging_dir) / "log.csv"
+        is_new = not Path(log_filepath).exists()
+        headers = [
+            getattr(component, "label", None) or f"component {idx}"
+            for idx, component in enumerate(self.components)
+        ] + [
+            "flag",
+            "username",
+            "timestamp",
+        ]
+
+        csv_data = []
+        for idx, (component, sample) in enumerate(zip(self.components, flag_data)):
+            save_dir = Path(flagging_dir) / utils.strip_invalid_filename_characters(
+                getattr(component, "label", None) or f"component {idx}"
+            )
+            if utils.is_update(sample):
+                csv_data.append(str(sample))
+            else:
+                csv_data.append(
+                    component.deserialize(sample, save_dir=save_dir)
+                    if sample is not None
+                    else ""
+                )
+        csv_data.append(flag_option)
+        csv_data.append(username if username is not None else "")
+        csv_data.append(str(datetime.datetime.now()))
+
+        with open(log_filepath, "a", newline="", encoding="utf-8") as csvfile:
+            writer = csv.writer(csvfile)
+            if is_new:
+                writer.writerow(utils.sanitize_list_for_csv(headers))
+            writer.writerow(utils.sanitize_list_for_csv(csv_data))
+
+        with open(log_filepath, "r", encoding="utf-8") as csvfile:
+            line_count = len([None for row in csv.reader(csvfile)]) - 1
+        return line_count
+
+
+@document()
+class HuggingFaceDatasetSaver(FlaggingCallback):
+    """
+    A callback that saves each flagged sample (both the input and output data)
+    to a HuggingFace dataset.
+    Example:
+        import gradio as gr
+        hf_writer = gr.HuggingFaceDatasetSaver(HF_API_TOKEN, "image-classification-mistakes")
+        def image_classifier(inp):
+            return {'cat': 0.3, 'dog': 0.7}
+        demo = gr.Interface(fn=image_classifier, inputs="image", outputs="label",
+                            allow_flagging="manual", flagging_callback=hf_writer)
+    Guides: using_flagging
+    """
+
+    def __init__(
+        self,
+        hf_token: str,
+        dataset_name: str,
+        organization: str | None = None,
+        private: bool = False,
+    ):
+        """
+        Parameters:
+            hf_token: The HuggingFace token to use to create (and write the flagged sample to) the HuggingFace dataset.
+            dataset_name: The name of the dataset to save the data to, e.g. "image-classifier-1"
+            organization: The organization to save the dataset under. The hf_token must provide write access to this organization. If not provided, saved under the name of the user corresponding to the hf_token.
+            private: Whether the dataset should be private (defaults to False).
+        """
+        self.hf_token = hf_token
+        self.dataset_name = dataset_name
+        self.organization_name = organization
+        self.dataset_private = private
+
+    def setup(self, components: List[IOComponent], flagging_dir: str):
+        """
+        Params:
+        flagging_dir (str): local directory where the dataset is cloned,
+        updated, and pushed from.
+        """
+        try:
+            import huggingface_hub
+        except (ImportError, ModuleNotFoundError):
+            raise ImportError(
+                "Package `huggingface_hub` not found is needed "
+                "for HuggingFaceDatasetSaver. Try 'pip install huggingface_hub'."
+            )
+        hh_version = pkg_resources.get_distribution("huggingface_hub").version
+        try:
+            if StrictVersion(hh_version) < StrictVersion("0.6.0"):
+                raise ImportError(
+                    "The `huggingface_hub` package must be version 0.6.0 or higher"
+                    "for HuggingFaceDatasetSaver. Try 'pip install huggingface_hub --upgrade'."
+                )
+        except ValueError:
+            pass
+        repo_id = huggingface_hub.get_full_repo_name(
+            self.dataset_name, token=self.hf_token
+        )
+        path_to_dataset_repo = huggingface_hub.create_repo(
+            repo_id=repo_id,
+            token=self.hf_token,
+            private=self.dataset_private,
+            repo_type="dataset",
+            exist_ok=True,
+        )
+        self.path_to_dataset_repo = path_to_dataset_repo  # e.g. "https://huggingface.co/datasets/abidlabs/test-audio-10"
+        self.components = components
+        self.flagging_dir = flagging_dir
+        self.dataset_dir = Path(flagging_dir) / self.dataset_name
+        self.repo = huggingface_hub.Repository(
+            local_dir=str(self.dataset_dir),
+            clone_from=path_to_dataset_repo,
+            use_auth_token=self.hf_token,
+        )
+        self.repo.git_pull(lfs=True)
+
+        # Should filename be user-specified?
+        self.log_file = Path(self.dataset_dir) / "data.csv"
+        self.infos_file = Path(self.dataset_dir) / "dataset_infos.json"
+
+    def flag(
+        self,
+        flag_data: List[Any],
+        flag_option: str = "",
+        username: str | None = None,
+    ) -> int:
+        self.repo.git_pull(lfs=True)
+
+        is_new = not Path(self.log_file).exists()
+
+        with open(self.log_file, "a", newline="", encoding="utf-8") as csvfile:
+            writer = csv.writer(csvfile)
+
+            # File previews for certain input and output types
+            infos, file_preview_types, headers = _get_dataset_features_info(
+                is_new, self.components
+            )
+
+            # Generate the headers and dataset_infos
+            if is_new:
+                writer.writerow(utils.sanitize_list_for_csv(headers))
+
+            # Generate the row corresponding to the flagged sample
+            csv_data = []
+            for component, sample in zip(self.components, flag_data):
+                save_dir = Path(
+                    self.dataset_dir
+                ) / utils.strip_invalid_filename_characters(component.label or "")
+                filepath = component.deserialize(sample, save_dir, None)
+                csv_data.append(filepath)
+                if isinstance(component, tuple(file_preview_types)):
+                    csv_data.append(
+                        "{}/resolve/main/{}".format(self.path_to_dataset_repo, filepath)
+                    )
+            csv_data.append(flag_option)
+            writer.writerow(utils.sanitize_list_for_csv(csv_data))
+
+        if is_new:
+            json.dump(infos, open(self.infos_file, "w"))
+
+        with open(self.log_file, "r", encoding="utf-8") as csvfile:
+            line_count = len([None for row in csv.reader(csvfile)]) - 1
+
+        self.repo.push_to_hub(commit_message="Flagged sample #{}".format(line_count))
+
+        return line_count
+
+
+class HuggingFaceDatasetJSONSaver(FlaggingCallback):
+    """
+    A FlaggingCallback that saves flagged data to a Hugging Face dataset in JSONL format.
+
+    Each data sample is saved in a different JSONL file,
+    allowing multiple users to use flagging simultaneously.
+    Saving to a single CSV would cause errors as only one user can edit at the same time.
+
+    """
+
+    def __init__(
+        self,
+        hf_token: str,
+        dataset_name: str,
+        organization: str | None = None,
+        private: bool = False,
+        verbose: bool = True,
+    ):
+        """
+        Params:
+        hf_token (str): The token to use to access the huggingface API.
+        dataset_name (str): The name of the dataset to save the data to, e.g.
+            "image-classifier-1"
+        organization (str): The name of the organization to which to attach
+            the datasets. If None, the dataset attaches to the user only.
+        private (bool): If the dataset does not already exist, whether it
+            should be created as a private dataset or public. Private datasets
+            may require paid huggingface.co accounts
+        verbose (bool): Whether to print out the status of the dataset
+            creation.
+        """
+        self.hf_token = hf_token
+        self.dataset_name = dataset_name
+        self.organization_name = organization
+        self.dataset_private = private
+        self.verbose = verbose
+
+    def setup(self, components: List[IOComponent], flagging_dir: str):
+        """
+        Params:
+        components List[Component]: list of components for flagging
+        flagging_dir (str): local directory where the dataset is cloned,
+        updated, and pushed from.
+        """
+        try:
+            import huggingface_hub
+        except (ImportError, ModuleNotFoundError):
+            raise ImportError(
+                "Package `huggingface_hub` not found is needed "
+                "for HuggingFaceDatasetJSONSaver. Try 'pip install huggingface_hub'."
+            )
+        hh_version = pkg_resources.get_distribution("huggingface_hub").version
+        try:
+            if StrictVersion(hh_version) < StrictVersion("0.6.0"):
+                raise ImportError(
+                    "The `huggingface_hub` package must be version 0.6.0 or higher"
+                    "for HuggingFaceDatasetSaver. Try 'pip install huggingface_hub --upgrade'."
+                )
+        except ValueError:
+            pass
+        repo_id = huggingface_hub.get_full_repo_name(
+            self.dataset_name, token=self.hf_token
+        )
+        path_to_dataset_repo = huggingface_hub.create_repo(
+            repo_id=repo_id,
+            token=self.hf_token,
+            private=self.dataset_private,
+            repo_type="dataset",
+            exist_ok=True,
+        )
+        self.path_to_dataset_repo = path_to_dataset_repo  # e.g. "https://huggingface.co/datasets/abidlabs/test-audio-10"
+        self.components = components
+        self.flagging_dir = flagging_dir
+        self.dataset_dir = Path(flagging_dir) / self.dataset_name
+        self.repo = huggingface_hub.Repository(
+            local_dir=str(self.dataset_dir),
+            clone_from=path_to_dataset_repo,
+            use_auth_token=self.hf_token,
+        )
+        self.repo.git_pull(lfs=True)
+
+        self.infos_file = Path(self.dataset_dir) / "dataset_infos.json"
+
+    def flag(
+        self,
+        flag_data: List[Any],
+        flag_option: str = "",
+        username: str | None = None,
+    ) -> str:
+        self.repo.git_pull(lfs=True)
+
+        # Generate unique folder for the flagged sample
+        unique_name = self.get_unique_name()  # unique name for folder
+        folder_name = (
+            Path(self.dataset_dir) / unique_name
+        )  # unique folder for specific example
+        os.makedirs(folder_name)
+
+        # Now uses the existence of `dataset_infos.json` to determine if new
+        is_new = not Path(self.infos_file).exists()
+
+        # File previews for certain input and output types
+        infos, file_preview_types, _ = _get_dataset_features_info(
+            is_new, self.components
+        )
+
+        # Generate the row and header corresponding to the flagged sample
+        csv_data = []
+        headers = []
+
+        for component, sample in zip(self.components, flag_data):
+            headers.append(component.label)
+
+            try:
+                save_dir = Path(folder_name) / utils.strip_invalid_filename_characters(
+                    component.label or ""
+                )
+                filepath = component.deserialize(sample, save_dir, None)
+            except Exception:
+                # Could not parse 'sample' (mostly) because it was None and `component.save_flagged`
+                # does not handle None cases.
+                # for example: Label (line 3109 of components.py raises an error if data is None)
+                filepath = None
+
+            if isinstance(component, tuple(file_preview_types)):
+                headers.append(component.label or "" + " file")
+
+                csv_data.append(
+                    "{}/resolve/main/{}/{}".format(
+                        self.path_to_dataset_repo, unique_name, filepath
+                    )
+                    if filepath is not None
+                    else None
+                )
+
+            csv_data.append(filepath)
+        headers.append("flag")
+        csv_data.append(flag_option)
+
+        # Creates metadata dict from row data and dumps it
+        metadata_dict = {
+            header: _csv_data for header, _csv_data in zip(headers, csv_data)
+        }
+        self.dump_json(metadata_dict, Path(folder_name) / "metadata.jsonl")
+
+        if is_new:
+            json.dump(infos, open(self.infos_file, "w"))
+
+        self.repo.push_to_hub(commit_message="Flagged sample {}".format(unique_name))
+        return unique_name
+
+    def get_unique_name(self):
+        id = uuid.uuid4()
+        return str(id)
+
+    def dump_json(self, thing: dict, file_path: str | Path) -> None:
+        with open(file_path, "w+", encoding="utf8") as f:
+            json.dump(thing, f)
+
+
+class FlagMethod:
+    """
+    Helper class that contains the flagging options and calls the flagging method. Also
+    provides visual feedback to the user when flag is clicked.
+    """
+
+    def __init__(
+        self,
+        flagging_callback: FlaggingCallback,
+        label: str,
+        value: str,
+        visual_feedback: bool = True,
+    ):
+        self.flagging_callback = flagging_callback
+        self.label = label
+        self.value = value
+        self.__name__ = "Flag"
+        self.visual_feedback = visual_feedback
+
+    def __call__(self, *flag_data):
+        try:
+            self.flagging_callback.flag(list(flag_data), flag_option=self.value)
+        except Exception as e:
+            print("Error while flagging: {}".format(e))
+            if self.visual_feedback:
+                return "Error!"
+        if not self.visual_feedback:
+            return
+        time.sleep(0.8)  # to provide enough time for the user to observe button change
+        return self.reset()
+
+    def reset(self):
+        return gr.Button.update(value=self.label, interactive=True)

gradio/helpers.py

@@ -0,0 +1,839 @@
+"""
+Defines helper methods useful for loading and caching Interface examples.
+"""
+from __future__ import annotations
+
+import ast
+import csv
+import inspect
+import os
+import subprocess
+import tempfile
+import threading
+import warnings
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Callable, Dict, Iterable, List, Tuple
+
+import matplotlib
+import matplotlib.pyplot as plt
+import numpy as np
+import PIL
+import PIL.Image
+
+from gradio import processing_utils, routes, utils
+from gradio.context import Context
+from gradio.documentation import document, set_documentation_group
+from gradio.flagging import CSVLogger
+
+if TYPE_CHECKING:  # Only import for type checking (to avoid circular imports).
+    from gradio.blocks import Block
+    from gradio.components import IOComponent
+
+CACHED_FOLDER = "gradio_cached_examples"
+LOG_FILE = "log.csv"
+
+set_documentation_group("helpers")
+
+
+def create_examples(
+    examples: List[Any] | List[List[Any]] | str,
+    inputs: IOComponent | List[IOComponent],
+    outputs: IOComponent | List[IOComponent] | None = None,
+    fn: Callable | None = None,
+    cache_examples: bool = False,
+    examples_per_page: int = 10,
+    _api_mode: bool = False,
+    label: str | None = None,
+    elem_id: str | None = None,
+    run_on_click: bool = False,
+    preprocess: bool = True,
+    postprocess: bool = True,
+    batch: bool = False,
+):
+    """Top-level synchronous function that creates Examples. Provided for backwards compatibility, i.e. so that gr.Examples(...) can be used to create the Examples component."""
+    examples_obj = Examples(
+        examples=examples,
+        inputs=inputs,
+        outputs=outputs,
+        fn=fn,
+        cache_examples=cache_examples,
+        examples_per_page=examples_per_page,
+        _api_mode=_api_mode,
+        label=label,
+        elem_id=elem_id,
+        run_on_click=run_on_click,
+        preprocess=preprocess,
+        postprocess=postprocess,
+        batch=batch,
+        _initiated_directly=False,
+    )
+    utils.synchronize_async(examples_obj.create)
+    return examples_obj
+
+
+@document()
+class Examples:
+    """
+    This class is a wrapper over the Dataset component and can be used to create Examples
+    for Blocks / Interfaces. Populates the Dataset component with examples and
+    assigns event listener so that clicking on an example populates the input/output
+    components. Optionally handles example caching for fast inference.
+
+    Demos: blocks_inputs, fake_gan
+    Guides: more_on_examples_and_flagging, using_hugging_face_integrations, image_classification_in_pytorch, image_classification_in_tensorflow, image_classification_with_vision_transformers, create_your_own_friends_with_a_gan
+    """
+
+    def __init__(
+        self,
+        examples: List[Any] | List[List[Any]] | str,
+        inputs: IOComponent | List[IOComponent],
+        outputs: IOComponent | List[IOComponent] | None = None,
+        fn: Callable | None = None,
+        cache_examples: bool = False,
+        examples_per_page: int = 10,
+        _api_mode: bool = False,
+        label: str | None = "Examples",
+        elem_id: str | None = None,
+        run_on_click: bool = False,
+        preprocess: bool = True,
+        postprocess: bool = True,
+        batch: bool = False,
+        _initiated_directly: bool = True,
+    ):
+        """
+        Parameters:
+            examples: example inputs that can be clicked to populate specific components. Should be nested list, in which the outer list consists of samples and each inner list consists of an input corresponding to each input component. A string path to a directory of examples can also be provided but it should be within the directory with the python file running the gradio app. If there are multiple input components and a directory is provided, a log.csv file must be present in the directory to link corresponding inputs.
+            inputs: the component or list of components corresponding to the examples
+            outputs: optionally, provide the component or list of components corresponding to the output of the examples. Required if `cache` is True.
+            fn: optionally, provide the function to run to generate the outputs corresponding to the examples. Required if `cache` is True.
+            cache_examples: if True, caches examples for fast runtime. If True, then `fn` and `outputs` need to be provided
+            examples_per_page: how many examples to show per page.
+            label: the label to use for the examples component (by default, "Examples")
+            elem_id: an optional string that is assigned as the id of this component in the HTML DOM.
+            run_on_click: if cache_examples is False, clicking on an example does not run the function when an example is clicked. Set this to True to run the function when an example is clicked. Has no effect if cache_examples is True.
+            preprocess: if True, preprocesses the example input before running the prediction function and caching the output. Only applies if cache_examples is True.
+            postprocess: if True, postprocesses the example output after running the prediction function and before caching. Only applies if cache_examples is True.
+            batch: If True, then the function should process a batch of inputs, meaning that it should accept a list of input values for each parameter. Used only if cache_examples is True.
+        """
+        if _initiated_directly:
+            warnings.warn(
+                "Please use gr.Examples(...) instead of gr.examples.Examples(...) to create the Examples.",
+            )
+
+        if cache_examples and (fn is None or outputs is None):
+            raise ValueError("If caching examples, `fn` and `outputs` must be provided")
+
+        if not isinstance(inputs, list):
+            inputs = [inputs]
+        if outputs and not isinstance(outputs, list):
+            outputs = [outputs]
+
+        working_directory = Path().absolute()
+
+        if examples is None:
+            raise ValueError("The parameter `examples` cannot be None")
+        elif isinstance(examples, list) and (
+            len(examples) == 0 or isinstance(examples[0], list)
+        ):
+            pass
+        elif (
+            isinstance(examples, list) and len(inputs) == 1
+        ):  # If there is only one input component, examples can be provided as a regular list instead of a list of lists
+            examples = [[e] for e in examples]
+        elif isinstance(examples, str):
+            if not Path(examples).exists():
+                raise FileNotFoundError(
+                    "Could not find examples directory: " + examples
+                )
+            working_directory = examples
+            if not (Path(examples) / LOG_FILE).exists():
+                if len(inputs) == 1:
+                    examples = [[e] for e in os.listdir(examples)]
+                else:
+                    raise FileNotFoundError(
+                        "Could not find log file (required for multiple inputs): "
+                        + LOG_FILE
+                    )
+            else:
+                with open(Path(examples) / LOG_FILE) as logs:
+                    examples = list(csv.reader(logs))
+                    examples = [
+                        examples[i][: len(inputs)] for i in range(1, len(examples))
+                    ]  # remove header and unnecessary columns
+
+        else:
+            raise ValueError(
+                "The parameter `examples` must either be a string directory or a list"
+                "(if there is only 1 input component) or (more generally), a nested "
+                "list, where each sublist represents a set of inputs."
+            )
+
+        input_has_examples = [False] * len(inputs)
+        for example in examples:
+            for idx, example_for_input in enumerate(example):
+                if not (example_for_input is None):
+                    try:
+                        input_has_examples[idx] = True
+                    except IndexError:
+                        pass  # If there are more example components than inputs, ignore. This can sometimes be intentional (e.g. loading from a log file where outputs and timestamps are also logged)
+
+        inputs_with_examples = [
+            inp for (inp, keep) in zip(inputs, input_has_examples) if keep
+        ]
+        non_none_examples = [
+            [ex for (ex, keep) in zip(example, input_has_examples) if keep]
+            for example in examples
+        ]
+
+        self.examples = examples
+        self.non_none_examples = non_none_examples
+        self.inputs = inputs
+        self.inputs_with_examples = inputs_with_examples
+        self.outputs = outputs
+        self.fn = fn
+        self.cache_examples = cache_examples
+        self._api_mode = _api_mode
+        self.preprocess = preprocess
+        self.postprocess = postprocess
+        self.batch = batch
+
+        with utils.set_directory(working_directory):
+            self.processed_examples = [
+                [
+                    component.postprocess(sample)
+                    for component, sample in zip(inputs, example)
+                ]
+                for example in examples
+            ]
+        self.non_none_processed_examples = [
+            [ex for (ex, keep) in zip(example, input_has_examples) if keep]
+            for example in self.processed_examples
+        ]
+        if cache_examples:
+            for example in self.examples:
+                if len([ex for ex in example if ex is not None]) != len(self.inputs):
+                    warnings.warn(
+                        "Examples are being cached but not all input components have "
+                        "example values. This may result in an exception being thrown by "
+                        "your function. If you do get an error while caching examples, make "
+                        "sure all of your inputs have example values for all of your examples "
+                        "or you provide default values for those particular parameters in your function."
+                    )
+                    break
+
+        from gradio import components
+
+        with utils.set_directory(working_directory):
+            self.dataset = components.Dataset(
+                components=inputs_with_examples,
+                samples=non_none_examples,
+                type="index",
+                label=label,
+                samples_per_page=examples_per_page,
+                elem_id=elem_id,
+            )
+
+        self.cached_folder = Path(CACHED_FOLDER) / str(self.dataset._id)
+        self.cached_file = Path(self.cached_folder) / "log.csv"
+        self.cache_examples = cache_examples
+        self.run_on_click = run_on_click
+
+    async def create(self) -> None:
+        """Caches the examples if self.cache_examples is True and creates the Dataset
+        component to hold the examples"""
+
+        async def load_example(example_id):
+            if self.cache_examples:
+                processed_example = self.non_none_processed_examples[
+                    example_id
+                ] + await self.load_from_cache(example_id)
+            else:
+                processed_example = self.non_none_processed_examples[example_id]
+            return utils.resolve_singleton(processed_example)
+
+        if Context.root_block:
+            if self.cache_examples and self.outputs:
+                targets = self.inputs_with_examples + self.outputs
+            else:
+                targets = self.inputs_with_examples
+            self.dataset.click(
+                load_example,
+                inputs=[self.dataset],
+                outputs=targets,  # type: ignore
+                show_progress=False,
+                postprocess=False,
+                queue=False,
+            )
+            if self.run_on_click and not self.cache_examples:
+                if self.fn is None:
+                    raise ValueError("Cannot run_on_click if no function is provided")
+                self.dataset.click(
+                    self.fn,
+                    inputs=self.inputs,  # type: ignore
+                    outputs=self.outputs,  # type: ignore
+                )
+
+        if self.cache_examples:
+            await self.cache()
+
+    async def cache(self) -> None:
+        """
+        Caches all of the examples so that their predictions can be shown immediately.
+        """
+        if Path(self.cached_file).exists():
+            print(
+                f"Using cache from '{utils.abspath(self.cached_folder)}' directory. If method or examples have changed since last caching, delete this folder to clear cache."
+            )
+        else:
+            if Context.root_block is None:
+                raise ValueError("Cannot cache examples if not in a Blocks context")
+
+            print(f"Caching examples at: '{utils.abspath(self.cached_folder)}'")
+            cache_logger = CSVLogger()
+
+            # create a fake dependency to process the examples and get the predictions
+            dependency, fn_index = Context.root_block.set_event_trigger(
+                event_name="fake_event",
+                fn=self.fn,
+                inputs=self.inputs_with_examples,  # type: ignore
+                outputs=self.outputs,  # type: ignore
+                preprocess=self.preprocess and not self._api_mode,
+                postprocess=self.postprocess and not self._api_mode,
+                batch=self.batch,
+            )
+
+            assert self.outputs is not None
+            cache_logger.setup(self.outputs, self.cached_folder)
+            for example_id, _ in enumerate(self.examples):
+                processed_input = self.processed_examples[example_id]
+                if self.batch:
+                    processed_input = [[value] for value in processed_input]
+                prediction = await Context.root_block.process_api(
+                    fn_index=fn_index, inputs=processed_input, request=None, state={}
+                )
+                output = prediction["data"]
+                if self.batch:
+                    output = [value[0] for value in output]
+                cache_logger.flag(output)
+            # Remove the "fake_event" to prevent bugs in loading interfaces from spaces
+            Context.root_block.dependencies.remove(dependency)
+            Context.root_block.fns.pop(fn_index)
+
+    async def load_from_cache(self, example_id: int) -> List[Any]:
+        """Loads a particular cached example for the interface.
+        Parameters:
+            example_id: The id of the example to process (zero-indexed).
+        """
+        with open(self.cached_file, encoding="utf-8") as cache:
+            examples = list(csv.reader(cache))
+        example = examples[example_id + 1]  # +1 to adjust for header
+        output = []
+        assert self.outputs is not None
+        for component, value in zip(self.outputs, example):
+            try:
+                value_as_dict = ast.literal_eval(value)
+                assert utils.is_update(value_as_dict)
+                output.append(value_as_dict)
+            except (ValueError, TypeError, SyntaxError, AssertionError):
+                output.append(component.serialize(value, self.cached_folder))
+        return output
+
+
+class TrackedIterable:
+    def __init__(
+        self,
+        iterable: Iterable | None,
+        index: int | None,
+        length: int | None,
+        desc: str | None,
+        unit: str | None,
+        _tqdm=None,
+        progress: float | None = None,
+    ) -> None:
+        self.iterable = iterable
+        self.index = index
+        self.length = length
+        self.desc = desc
+        self.unit = unit
+        self._tqdm = _tqdm
+        self.progress = progress
+
+
+@document("__call__", "tqdm")
+class Progress(Iterable):
+    """
+    The Progress class provides a custom progress tracker that is used in a function signature.
+    To attach a Progress tracker to a function, simply add a parameter right after the input parameters that has a default value set to a `gradio.Progress()` instance.
+    The Progress tracker can then be updated in the function by calling the Progress object or using the `tqdm` method on an Iterable.
+    The Progress tracker is currently only available with `queue()`.
+    Example:
+        import gradio as gr
+        import time
+        def my_function(x, progress=gr.Progress()):
+            progress(0, desc="Starting...")
+            time.sleep(1)
+            for i in progress.tqdm(range(100)):
+                time.sleep(0.1)
+            return x
+        gr.Interface(my_function, gr.Textbox(), gr.Textbox()).queue().launch()
+    Demos: progress
+    """
+
+    def __init__(
+        self,
+        track_tqdm: bool = False,
+        _callback: Callable | None = None,  # for internal use only
+        _event_id: str | None = None,
+    ):
+        """
+        Parameters:
+            track_tqdm: If True, the Progress object will track any tqdm.tqdm iterations with the tqdm library in the function.
+        """
+        self.track_tqdm = track_tqdm
+        self._callback = _callback
+        self._event_id = _event_id
+        self.iterables: List[TrackedIterable] = []
+
+    def __len__(self):
+        return self.iterables[-1].length
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        """
+        Updates progress tracker with next item in iterable.
+        """
+        if self._callback:
+            current_iterable = self.iterables[-1]
+            while (
+                not hasattr(current_iterable.iterable, "__next__")
+                and len(self.iterables) > 0
+            ):
+                current_iterable = self.iterables.pop()
+            self._callback(
+                event_id=self._event_id,
+                iterables=self.iterables,
+            )
+            assert current_iterable.index is not None, "Index not set."
+            current_iterable.index += 1
+            try:
+                return next(current_iterable.iterable)  # type: ignore
+            except StopIteration:
+                self.iterables.pop()
+                raise StopIteration
+        else:
+            return self
+
+    def __call__(
+        self,
+        progress: float | Tuple[int, int | None] | None,
+        desc: str | None = None,
+        total: int | None = None,
+        unit: str = "steps",
+        _tqdm=None,
+    ):
+        """
+        Updates progress tracker with progress and message text.
+        Parameters:
+            progress: If float, should be between 0 and 1 representing completion. If Tuple, first number represents steps completed, and second value represents total steps or None if unknown. If None, hides progress bar.
+            desc: description to display.
+            total: estimated total number of steps.
+            unit: unit of iterations.
+        """
+        if self._callback:
+            if isinstance(progress, tuple):
+                index, total = progress
+                progress = None
+            else:
+                index = None
+            self._callback(
+                event_id=self._event_id,
+                iterables=self.iterables
+                + [TrackedIterable(None, index, total, desc, unit, _tqdm, progress)],
+            )
+        else:
+            return progress
+
+    def tqdm(
+        self,
+        iterable: Iterable | None,
+        desc: str | None = None,
+        total: int | None = None,
+        unit: str = "steps",
+        _tqdm=None,
+        *args,
+        **kwargs,
+    ):
+        """
+        Attaches progress tracker to iterable, like tqdm.
+        Parameters:
+            iterable: iterable to attach progress tracker to.
+            desc: description to display.
+            total: estimated total number of steps.
+            unit: unit of iterations.
+        """
+        if self._callback:
+            if iterable is None:
+                new_iterable = TrackedIterable(None, 0, total, desc, unit, _tqdm)
+                self.iterables.append(new_iterable)
+                self._callback(event_id=self._event_id, iterables=self.iterables)
+                return self
+            length = len(iterable) if hasattr(iterable, "__len__") else None  # type: ignore
+            self.iterables.append(
+                TrackedIterable(iter(iterable), 0, length, desc, unit, _tqdm)
+            )
+        return self
+
+    def update(self, n=1):
+        """
+        Increases latest iterable with specified number of steps.
+        Parameters:
+            n: number of steps completed.
+        """
+        if self._callback and len(self.iterables) > 0:
+            current_iterable = self.iterables[-1]
+            assert current_iterable.index is not None, "Index not set."
+            current_iterable.index += n
+            self._callback(
+                event_id=self._event_id,
+                iterables=self.iterables,
+            )
+        else:
+            return
+
+    def close(self, _tqdm):
+        """
+        Removes iterable with given _tqdm.
+        """
+        if self._callback:
+            for i in range(len(self.iterables)):
+                if id(self.iterables[i]._tqdm) == id(_tqdm):
+                    self.iterables.pop(i)
+                    break
+            self._callback(
+                event_id=self._event_id,
+                iterables=self.iterables,
+            )
+        else:
+            return
+
+
+def create_tracker(root_blocks, event_id, fn, track_tqdm):
+
+    progress = Progress(_callback=root_blocks._queue.set_progress, _event_id=event_id)
+    if not track_tqdm:
+        return progress, fn
+
+    try:
+        _tqdm = __import__("tqdm")
+    except ModuleNotFoundError:
+        return progress, fn
+    if not hasattr(root_blocks, "_progress_tracker_per_thread"):
+        root_blocks._progress_tracker_per_thread = {}
+
+    def init_tqdm(self, iterable=None, desc=None, *args, **kwargs):
+        self._progress = root_blocks._progress_tracker_per_thread.get(
+            threading.get_ident()
+        )
+        if self._progress is not None:
+            self._progress.event_id = event_id
+            self._progress.tqdm(iterable, desc, _tqdm=self, *args, **kwargs)
+            kwargs["file"] = open(os.devnull, "w")
+        self.__init__orig__(iterable, desc, *args, **kwargs)
+
+    def iter_tqdm(self):
+        if self._progress is not None:
+            return self._progress
+        else:
+            return self.__iter__orig__()
+
+    def update_tqdm(self, n=1):
+        if self._progress is not None:
+            self._progress.update(n)
+        return self.__update__orig__(n)
+
+    def close_tqdm(self):
+        if self._progress is not None:
+            self._progress.close(self)
+        return self.__close__orig__()
+
+    def exit_tqdm(self, exc_type, exc_value, traceback):
+        if self._progress is not None:
+            self._progress.close(self)
+        return self.__exit__orig__(exc_type, exc_value, traceback)
+
+    if not hasattr(_tqdm.tqdm, "__init__orig__"):
+        _tqdm.tqdm.__init__orig__ = _tqdm.tqdm.__init__
+    _tqdm.tqdm.__init__ = init_tqdm
+    if not hasattr(_tqdm.tqdm, "__update__orig__"):
+        _tqdm.tqdm.__update__orig__ = _tqdm.tqdm.update
+    _tqdm.tqdm.update = update_tqdm
+    if not hasattr(_tqdm.tqdm, "__close__orig__"):
+        _tqdm.tqdm.__close__orig__ = _tqdm.tqdm.close
+    _tqdm.tqdm.close = close_tqdm
+    if not hasattr(_tqdm.tqdm, "__exit__orig__"):
+        _tqdm.tqdm.__exit__orig__ = _tqdm.tqdm.__exit__
+    _tqdm.tqdm.__exit__ = exit_tqdm
+    if not hasattr(_tqdm.tqdm, "__iter__orig__"):
+        _tqdm.tqdm.__iter__orig__ = _tqdm.tqdm.__iter__
+    _tqdm.tqdm.__iter__ = iter_tqdm
+    if hasattr(_tqdm, "auto") and hasattr(_tqdm.auto, "tqdm"):
+        _tqdm.auto.tqdm = _tqdm.tqdm
+
+    def tracked_fn(*args):
+        thread_id = threading.get_ident()
+        root_blocks._progress_tracker_per_thread[thread_id] = progress
+        response = fn(*args)
+        del root_blocks._progress_tracker_per_thread[thread_id]
+        return response
+
+    return progress, tracked_fn
+
+
+def special_args(
+    fn: Callable,
+    inputs: List[Any] | None = None,
+    request: routes.Request | None = None,
+    event_data: EventData | None = None,
+):
+    """
+    Checks if function has special arguments Request or EventData (via annotation) or Progress (via default value).
+    If inputs is provided, these values will be loaded into the inputs array.
+    Parameters:
+        block_fn: function to check.
+        inputs: array to load special arguments into.
+        request: request to load into inputs.
+    Returns:
+        updated inputs, progress index, event data index.
+    """
+    signature = inspect.signature(fn)
+    positional_args = []
+    for i, param in enumerate(signature.parameters.values()):
+        if param.kind not in (param.POSITIONAL_ONLY, param.POSITIONAL_OR_KEYWORD):
+            break
+        positional_args.append(param)
+    progress_index = None
+    event_data_index = None
+    for i, param in enumerate(positional_args):
+        if isinstance(param.default, Progress):
+            progress_index = i
+            if inputs is not None:
+                inputs.insert(i, param.default)
+        elif param.annotation == routes.Request:
+            if inputs is not None:
+                inputs.insert(i, request)
+        elif isinstance(param.annotation, type) and issubclass(
+            param.annotation, EventData
+        ):
+            event_data_index = i
+            if inputs is not None and event_data is not None:
+                inputs.insert(i, param.annotation(event_data.target, event_data._data))
+    if inputs is not None:
+        while len(inputs) < len(positional_args):
+            i = len(inputs)
+            param = positional_args[i]
+            if param.default == param.empty:
+                warnings.warn("Unexpected argument. Filling with None.")
+                inputs.append(None)
+            else:
+                inputs.append(param.default)
+    return inputs or [], progress_index, event_data_index
+
+
+@document()
+def update(**kwargs) -> dict:
+    """
+    Updates component properties. When a function passed into a Gradio Interface or a Blocks events returns a typical value, it updates the value of the output component. But it is also possible to update the properties of an output component (such as the number of lines of a `Textbox` or the visibility of an `Image`) by returning the component's `update()` function, which takes as parameters any of the constructor parameters for that component.
+    This is a shorthand for using the update method on a component.
+    For example, rather than using gr.Number.update(...) you can just use gr.update(...).
+    Note that your editor's autocompletion will suggest proper parameters
+    if you use the update method on the component.
+    Demos: blocks_essay, blocks_update, blocks_essay_update
+
+    Parameters:
+        kwargs: Key-word arguments used to update the component's properties.
+    Example:
+        # Blocks Example
+        import gradio as gr
+        with gr.Blocks() as demo:
+            radio = gr.Radio([1, 2, 4], label="Set the value of the number")
+            number = gr.Number(value=2, interactive=True)
+            radio.change(fn=lambda value: gr.update(value=value), inputs=radio, outputs=number)
+        demo.launch()
+
+        # Interface example
+        import gradio as gr
+        def change_textbox(choice):
+          if choice == "short":
+              return gr.Textbox.update(lines=2, visible=True)
+          elif choice == "long":
+              return gr.Textbox.update(lines=8, visible=True)
+          else:
+              return gr.Textbox.update(visible=False)
+        gr.Interface(
+          change_textbox,
+          gr.Radio(
+              ["short", "long", "none"], label="What kind of essay would you like to write?"
+          ),
+          gr.Textbox(lines=2),
+          live=True,
+        ).launch()
+    """
+    kwargs["__type__"] = "generic_update"
+    return kwargs
+
+
+def skip() -> dict:
+    return update()
+
+
+@document()
+def make_waveform(
+    audio: str | Tuple[int, np.ndarray],
+    *,
+    bg_color: str = "#f3f4f6",
+    bg_image: str | None = None,
+    fg_alpha: float = 0.75,
+    bars_color: str | Tuple[str, str] = ("#fbbf24", "#ea580c"),
+    bar_count: int = 50,
+    bar_width: float = 0.6,
+):
+    """
+    Generates a waveform video from an audio file. Useful for creating an easy to share audio visualization. The output should be passed into a `gr.Video` component.
+    Parameters:
+        audio: Audio file path or tuple of (sample_rate, audio_data)
+        bg_color: Background color of waveform (ignored if bg_image is provided)
+        bg_image: Background image of waveform
+        fg_alpha: Opacity of foreground waveform
+        bars_color: Color of waveform bars. Can be a single color or a tuple of (start_color, end_color) of gradient
+        bar_count: Number of bars in waveform
+        bar_width: Width of bars in waveform. 1 represents full width, 0.5 represents half width, etc.
+    Returns:
+        A filepath to the output video.
+    """
+    if isinstance(audio, str):
+        audio_file = audio
+        audio = processing_utils.audio_from_file(audio)
+    else:
+        tmp_wav = tempfile.NamedTemporaryFile(suffix=".wav", delete=False)
+        processing_utils.audio_to_file(audio[0], audio[1], tmp_wav.name)
+        audio_file = tmp_wav.name
+    duration = round(len(audio[1]) / audio[0], 4)
+
+    # Helper methods to create waveform
+    def hex_to_RGB(hex_str):
+        return [int(hex_str[i : i + 2], 16) for i in range(1, 6, 2)]
+
+    def get_color_gradient(c1, c2, n):
+        assert n > 1
+        c1_rgb = np.array(hex_to_RGB(c1)) / 255
+        c2_rgb = np.array(hex_to_RGB(c2)) / 255
+        mix_pcts = [x / (n - 1) for x in range(n)]
+        rgb_colors = [((1 - mix) * c1_rgb + (mix * c2_rgb)) for mix in mix_pcts]
+        return [
+            "#" + "".join([format(int(round(val * 255)), "02x") for val in item])
+            for item in rgb_colors
+        ]
+
+    # Reshape audio to have a fixed number of bars
+    samples = audio[1]
+    if len(samples.shape) > 1:
+        samples = np.mean(samples, 1)
+    bins_to_pad = bar_count - (len(samples) % bar_count)
+    samples = np.pad(samples, [(0, bins_to_pad)])
+    samples = np.reshape(samples, (bar_count, -1))
+    samples = np.abs(samples)
+    samples = np.max(samples, 1)
+
+    matplotlib.use("Agg")
+    plt.clf()
+    # Plot waveform
+    color = (
+        bars_color
+        if isinstance(bars_color, str)
+        else get_color_gradient(bars_color[0], bars_color[1], bar_count)
+    )
+    plt.bar(
+        np.arange(0, bar_count),
+        samples * 2,
+        bottom=(-1 * samples),
+        width=bar_width,
+        color=color,
+    )
+    plt.axis("off")
+    plt.margins(x=0)
+    tmp_img = tempfile.NamedTemporaryFile(suffix=".png", delete=False)
+    savefig_kwargs: Dict[str, Any] = {"bbox_inches": "tight"}
+    if bg_image is not None:
+        savefig_kwargs["transparent"] = True
+    else:
+        savefig_kwargs["facecolor"] = bg_color
+    plt.savefig(tmp_img.name, **savefig_kwargs)
+    waveform_img = PIL.Image.open(tmp_img.name)
+    waveform_img = waveform_img.resize((1000, 200))
+
+    # Composite waveform with background image
+    if bg_image is not None:
+        waveform_array = np.array(waveform_img)
+        waveform_array[:, :, 3] = waveform_array[:, :, 3] * fg_alpha
+        waveform_img = PIL.Image.fromarray(waveform_array)
+
+        bg_img = PIL.Image.open(bg_image)
+        waveform_width, waveform_height = waveform_img.size
+        bg_width, bg_height = bg_img.size
+        if waveform_width != bg_width:
+            bg_img = bg_img.resize(
+                (waveform_width, 2 * int(bg_height * waveform_width / bg_width / 2))
+            )
+            bg_width, bg_height = bg_img.size
+        composite_height = max(bg_height, waveform_height)
+        composite = PIL.Image.new("RGBA", (waveform_width, composite_height), "#FFFFFF")
+        composite.paste(bg_img, (0, composite_height - bg_height))
+        composite.paste(
+            waveform_img, (0, composite_height - waveform_height), waveform_img
+        )
+        composite.save(tmp_img.name)
+        img_width, img_height = composite.size
+    else:
+        img_width, img_height = waveform_img.size
+        waveform_img.save(tmp_img.name)
+
+    # Convert waveform to video with ffmpeg
+    output_mp4 = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False)
+
+    ffmpeg_cmd = f"""ffmpeg -loop 1 -i {tmp_img.name} -i {audio_file} -vf "color=c=#FFFFFF77:s={img_width}x{img_height}[bar];[0][bar]overlay=-w+(w/{duration})*t:H-h:shortest=1" -t {duration} -y {output_mp4.name}"""
+
+    subprocess.call(ffmpeg_cmd, shell=True)
+    return output_mp4.name
+
+
+@document()
+class EventData:
+    """
+    When a subclass of EventData is added as a type hint to an argument of an event listener method, this object will be passed as that argument.
+    It contains information about the event that triggered the listener, such the target object, and other data related to the specific event that are attributes of the subclass.
+
+    Example:
+        table = gr.Dataframe([[1, 2, 3], [4, 5, 6]])
+        gallery = gr.Gallery([("cat.jpg", "Cat"), ("dog.jpg", "Dog")])
+        textbox = gr.Textbox("Hello World!")
+
+        statement = gr.Textbox()
+
+        def on_select(evt: gr.SelectData):  # SelectData is a subclass of EventData
+            return f"You selected {evt.value} at {evt.index} from {evt.target}"
+
+        table.select(on_select, None, statement)
+        gallery.select(on_select, None, statement)
+        textbox.select(on_select, None, statement)
+    Demos: gallery_selections, tictactoe
+    """
+
+    def __init__(self, target: Block | None, _data: Any):
+        """
+        Parameters:
+            target: The target object that triggered the event. Can be used to distinguish if multiple components are bound to the same listener.
+        """
+        self.target = target
+        self._data = _data

gradio/inputs.py

@@ -0,0 +1,473 @@
+# type: ignore
+"""
+This module defines various classes that can serve as the `input` to an interface. Each class must inherit from
+`InputComponent`, and each class must define a path to its template. All of the subclasses of `InputComponent` are
+automatically added to a registry, which allows them to be easily referenced in other parts of the code.
+"""
+
+from __future__ import annotations
+
+import warnings
+from typing import Any, List, Optional, Tuple
+
+from gradio import components
+
+
+class Textbox(components.Textbox):
+    def __init__(
+        self,
+        lines: int = 1,
+        placeholder: Optional[str] = None,
+        default: str = "",
+        numeric: Optional[bool] = False,
+        type: Optional[str] = "text",
+        label: Optional[str] = None,
+        optional: bool = False,
+    ):
+        warnings.warn(
+            "Usage of gradio.inputs is deprecated, and will not be supported in the future, please import your component from gradio.components",
+        )
+        super().__init__(
+            value=default,
+            lines=lines,
+            placeholder=placeholder,
+            label=label,
+            numeric=numeric,
+            type=type,
+            optional=optional,
+        )
+
+
+class Number(components.Number):
+    """
+    Component creates a field for user to enter numeric input. Provides a number as an argument to the wrapped function.
+    Input type: float
+    """
+
+    def __init__(
+        self,
+        default: Optional[float] = None,
+        label: Optional[str] = None,
+        optional: bool = False,
+    ):
+        """
+        Parameters:
+        default (float): default value.
+        label (str): component name in interface.
+        optional (bool): If True, the interface can be submitted with no value for this component.
+        """
+        warnings.warn(
+            "Usage of gradio.inputs is deprecated, and will not be supported in the future, please import your component from gradio.components",
+        )
+        super().__init__(value=default, label=label, optional=optional)
+
+
+class Slider(components.Slider):
+    """
+    Component creates a slider that ranges from `minimum` to `maximum`. Provides number as an argument to the wrapped function.
+    Input type: float
+    """
+
+    def __init__(
+        self,
+        minimum: float = 0,
+        maximum: float = 100,
+        step: Optional[float] = None,
+        default: Optional[float] = None,
+        label: Optional[str] = None,
+        optional: bool = False,
+    ):
+        """
+        Parameters:
+        minimum (float): minimum value for slider.
+        maximum (float): maximum value for slider.
+        step (float): increment between slider values.
+        default (float): default value.
+        label (str): component name in interface.
+        optional (bool): this parameter is ignored.
+        """
+        warnings.warn(
+            "Usage of gradio.inputs is deprecated, and will not be supported in the future, please import your component from gradio.components",
+        )
+
+        super().__init__(
+            value=default,
+            minimum=minimum,
+            maximum=maximum,
+            step=step,
+            label=label,
+            optional=optional,
+        )
+
+
+class Checkbox(components.Checkbox):
+    """
+    Component creates a checkbox that can be set to `True` or `False`. Provides a boolean as an argument to the wrapped function.
+    Input type: bool
+    """
+
+    def __init__(
+        self,
+        default: bool = False,
+        label: Optional[str] = None,
+        optional: bool = False,
+    ):
+        """
+        Parameters:
+        label (str): component name in interface.
+        default (bool): if True, checked by default.
+        optional (bool): this parameter is ignored.
+        """
+        warnings.warn(
+            "Usage of gradio.inputs is deprecated, and will not be supported in the future, please import your component from gradio.components",
+        )
+        super().__init__(value=default, label=label, optional=optional)
+
+
+class CheckboxGroup(components.CheckboxGroup):
+    """
+    Component creates a set of checkboxes of which a subset can be selected. Provides a list of strings representing the selected choices as an argument to the wrapped function.
+    Input type: Union[List[str], List[int]]
+    """
+
+    def __init__(
+        self,
+        choices: List[str],
+        default: List[str] = [],
+        type: str = "value",
+        label: Optional[str] = None,
+        optional: bool = False,
+    ):
+        """
+        Parameters:
+        choices (List[str]): list of options to select from.
+        default (List[str]): default selected list of options.
+        type (str): Type of value to be returned by component. "value" returns the list of strings of the choices selected, "index" returns the list of indicies of the choices selected.
+        label (str): component name in interface.
+        optional (bool): this parameter is ignored.
+        """
+        warnings.warn(
+            "Usage of gradio.inputs is deprecated, and will not be supported in the future, please import your component from gradio.components",
+        )
+        super().__init__(
+            value=default,
+            choices=choices,
+            type=type,
+            label=label,
+            optional=optional,
+        )
+
+
+class Radio(components.Radio):
+    """
+    Component creates a set of radio buttons of which only one can be selected. Provides string representing selected choice as an argument to the wrapped function.
+    Input type: Union[str, int]
+    """
+
+    def __init__(
+        self,
+        choices: List[str],
+        type: str = "value",
+        default: Optional[str] = None,
+        label: Optional[str] = None,
+        optional: bool = False,
+    ):
+        """
+        Parameters:
+        choices (List[str]): list of options to select from.
+        type (str): Type of value to be returned by component. "value" returns the string of the choice selected, "index" returns the index of the choice selected.
+        default (str): the button selected by default. If None, no button is selected by default.
+        label (str): component name in interface.
+        optional (bool): this parameter is ignored.
+        """
+        warnings.warn(
+            "Usage of gradio.inputs is deprecated, and will not be supported in the future, please import your component from gradio.components",
+        )
+        super().__init__(
+            choices=choices,
+            type=type,
+            value=default,
+            label=label,
+            optional=optional,
+        )
+
+
+class Dropdown(components.Dropdown):
+    """
+    Component creates a dropdown of which only one can be selected. Provides string representing selected choice as an argument to the wrapped function.
+    Input type: Union[str, int]
+    """
+
+    def __init__(
+        self,
+        choices: List[str],
+        type: str = "value",
+        default: Optional[str] = None,
+        label: Optional[str] = None,
+        optional: bool = False,
+    ):
+        """
+        Parameters:
+        choices (List[str]): list of options to select from.
+        type (str): Type of value to be returned by component. "value" returns the string of the choice selected, "index" returns the index of the choice selected.
+        default (str): default value selected in dropdown. If None, no value is selected by default.
+        label (str): component name in interface.
+        optional (bool): this parameter is ignored.
+        """
+        warnings.warn(
+            "Usage of gradio.inputs is deprecated, and will not be supported in the future, please import your component from gradio.components",
+        )
+        super().__init__(
+            choices=choices,
+            type=type,
+            value=default,
+            label=label,
+            optional=optional,
+        )
+
+
+class Image(components.Image):
+    """
+    Component creates an image upload box with editing capabilities.
+    Input type: Union[numpy.array, PIL.Image, file-object]
+    """
+
+    def __init__(
+        self,
+        shape: Tuple[int, int] = None,
+        image_mode: str = "RGB",
+        invert_colors: bool = False,
+        source: str = "upload",
+        tool: str = "editor",
+        type: str = "numpy",
+        label: str = None,
+        optional: bool = False,
+    ):
+        """
+        Parameters:
+        shape (Tuple[int, int]): (width, height) shape to crop and resize image to; if None, matches input image size.
+        image_mode (str): How to process the uploaded image. Accepts any of the PIL image modes, e.g. "RGB" for color images, "RGBA" to include the transparency mask, "L" for black-and-white images.
+        invert_colors (bool): whether to invert the image as a preprocessing step.
+        source (str): Source of image. "upload" creates a box where user can drop an image file, "webcam" allows user to take snapshot from their webcam, "canvas" defaults to a white image that can be edited and drawn upon with tools.
+        tool (str): Tools used for editing. "editor" allows a full screen editor, "select" provides a cropping and zoom tool.
+        type (str): Type of value to be returned by component. "numpy" returns a numpy array with shape (width, height, 3) and values from 0 to 255, "pil" returns a PIL image object, "file" returns a temporary file object whose path can be retrieved by file_obj.name, "filepath" returns the path directly.
+        label (str): component name in interface.
+        optional (bool): If True, the interface can be submitted with no uploaded image, in which case the input value is None.
+        """
+        warnings.warn(
+            "Usage of gradio.inputs is deprecated, and will not be supported in the future, please import your component from gradio.components",
+        )
+        super().__init__(
+            shape=shape,
+            image_mode=image_mode,
+            invert_colors=invert_colors,
+            source=source,
+            tool=tool,
+            type=type,
+            label=label,
+            optional=optional,
+        )
+
+
+class Video(components.Video):
+    """
+    Component creates a video file upload that is converted to a file path.
+
+    Input type: filepath
+    """
+
+    def __init__(
+        self,
+        type: Optional[str] = None,
+        source: str = "upload",
+        label: Optional[str] = None,
+        optional: bool = False,
+    ):
+        """
+        Parameters:
+        type (str): Type of video format to be returned by component, such as 'avi' or 'mp4'. If set to None, video will keep uploaded format.
+        source (str): Source of video. "upload" creates a box where user can drop an video file, "webcam" allows user to record a video from their webcam.
+        label (str): component name in interface.
+        optional (bool): If True, the interface can be submitted with no uploaded video, in which case the input value is None.
+        """
+        warnings.warn(
+            "Usage of gradio.inputs is deprecated, and will not be supported in the future, please import your components from gradio.components",
+        )
+        super().__init__(format=type, source=source, label=label, optional=optional)
+
+
+class Audio(components.Audio):
+    """
+    Component accepts audio input files.
+    Input type: Union[Tuple[int, numpy.array], file-object, numpy.array]
+    """
+
+    def __init__(
+        self,
+        source: str = "upload",
+        type: str = "numpy",
+        label: str = None,
+        optional: bool = False,
+    ):
+        """
+        Parameters:
+        source (str): Source of audio. "upload" creates a box where user can drop an audio file, "microphone" creates a microphone input.
+        type (str): Type of value to be returned by component. "numpy" returns a 2-set tuple with an integer sample_rate and the data numpy.array of shape (samples, 2), "file" returns a temporary file object whose path can be retrieved by file_obj.name, "filepath" returns the path directly.
+        label (str): component name in interface.
+        optional (bool): If True, the interface can be submitted with no uploaded audio, in which case the input value is None.
+        """
+        warnings.warn(
+            "Usage of gradio.inputs is deprecated, and will not be supported in the future, please import your components from gradio.components",
+        )
+        super().__init__(source=source, type=type, label=label, optional=optional)
+
+
+class File(components.File):
+    """
+    Component accepts generic file uploads.
+    Input type: Union[file-object, bytes, List[Union[file-object, bytes]]]
+    """
+
+    def __init__(
+        self,
+        file_count: str = "single",
+        type: str = "file",
+        label: Optional[str] = None,
+        keep_filename: bool = True,
+        optional: bool = False,
+    ):
+        """
+        Parameters:
+        file_count (str): if single, allows user to upload one file. If "multiple", user uploads multiple files. If "directory", user uploads all files in selected directory. Return type will be list for each file in case of "multiple" or "directory".
+        type (str): Type of value to be returned by component. "file" returns a temporary file object whose path can be retrieved by file_obj.name, "binary" returns an bytes object.
+        label (str): component name in interface.
+        keep_filename (bool): DEPRECATED. Original filename always kept.
+        optional (bool): If True, the interface can be submitted with no uploaded image, in which case the input value is None.
+        """
+        warnings.warn(
+            "Usage of gradio.inputs is deprecated, and will not be supported in the future, please import your components from gradio.components",
+        )
+        super().__init__(
+            file_count=file_count,
+            type=type,
+            label=label,
+            keep_filename=keep_filename,
+            optional=optional,
+        )
+
+
+class Dataframe(components.Dataframe):
+    """
+    Component accepts 2D input through a spreadsheet interface.
+    Input type: Union[pandas.DataFrame, numpy.array, List[Union[str, float]], List[List[Union[str, float]]]]
+    """
+
+    def __init__(
+        self,
+        headers: Optional[List[str]] = None,
+        row_count: int = 3,
+        col_count: Optional[int] = 3,
+        datatype: str | List[str] = "str",
+        col_width: int | List[int] = None,
+        default: Optional[List[List[Any]]] = None,
+        type: str = "pandas",
+        label: Optional[str] = None,
+        optional: bool = False,
+    ):
+        """
+        Parameters:
+        headers (List[str]): Header names to dataframe. If None, no headers are shown.
+        row_count (int): Limit number of rows for input.
+        col_count (int): Limit number of columns for input. If equal to 1, return data will be one-dimensional. Ignored if `headers` is provided.
+        datatype (Union[str, List[str]]): Datatype of values in sheet. Can be provided per column as a list of strings, or for the entire sheet as a single string. Valid datatypes are "str", "number", "bool", and "date".
+        col_width (Union[int, List[int]]): Width of columns in pixels. Can be provided as single value or list of values per column.
+        default (List[List[Any]]): Default value
+        type (str): Type of value to be returned by component. "pandas" for pandas dataframe, "numpy" for numpy array, or "array" for a Python array.
+        label (str): component name in interface.
+        optional (bool): this parameter is ignored.
+        """
+        warnings.warn(
+            "Usage of gradio.inputs is deprecated, and will not be supported in the future, please import your components from gradio.components",
+        )
+        super().__init__(
+            value=default,
+            headers=headers,
+            row_count=row_count,
+            col_count=col_count,
+            datatype=datatype,
+            col_width=col_width,
+            type=type,
+            label=label,
+            optional=optional,
+        )
+
+
+class Timeseries(components.Timeseries):
+    """
+    Component accepts pandas.DataFrame uploaded as a timeseries csv file.
+    Input type: pandas.DataFrame
+    """
+
+    def __init__(
+        self,
+        x: Optional[str] = None,
+        y: str | List[str] = None,
+        label: Optional[str] = None,
+        optional: bool = False,
+    ):
+        """
+        Parameters:
+        x (str): Column name of x (time) series. None if csv has no headers, in which case first column is x series.
+        y (Union[str, List[str]]): Column name of y series, or list of column names if multiple series. None if csv has no headers, in which case every column after first is a y series.
+        label (str): component name in interface.
+        optional (bool): If True, the interface can be submitted with no uploaded csv file, in which case the input value is None.
+        """
+        warnings.warn(
+            "Usage of gradio.inputs is deprecated, and will not be supported in the future, please import your components from gradio.components",
+        )
+        super().__init__(x=x, y=y, label=label, optional=optional)
+
+
+class State(components.State):
+    """
+    Special hidden component that stores state across runs of the interface.
+    Input type: Any
+    """
+
+    def __init__(
+        self,
+        label: str = None,
+        default: Any = None,
+    ):
+        """
+        Parameters:
+        label (str): component name in interface (not used).
+        default (Any): the initial value of the state.
+        optional (bool): this parameter is ignored.
+        """
+        warnings.warn(
+            "Usage of gradio.inputs is deprecated, and will not be supported in the future, please import this component as gr.State() from gradio.components",
+        )
+        super().__init__(value=default, label=label)
+
+
+class Image3D(components.Model3D):
+    """
+    Used for 3D image model output.
+    Input type: File object of type (.obj, glb, or .gltf)
+    """
+
+    def __init__(
+        self,
+        label: Optional[str] = None,
+        optional: bool = False,
+    ):
+        """
+        Parameters:
+        label (str): component name in interface.
+        optional (bool): If True, the interface can be submitted with no uploaded image, in which case the input value is None.
+        """
+        warnings.warn(
+            "Usage of gradio.outputs is deprecated, and will not be supported in the future, please import your components from gradio.components",
+        )
+        super().__init__(label=label, optional=optional)

gradio/interface.py

@@ -0,0 +1,888 @@
+"""
+This is the core file in the `gradio` package, and defines the Interface class,
+including various methods for constructing an interface and then launching it.
+"""
+
+from __future__ import annotations
+
+import inspect
+import json
+import os
+import re
+import warnings
+import weakref
+from typing import TYPE_CHECKING, Any, Callable, List, Tuple
+
+from gradio import Examples, interpretation, utils
+from gradio.blocks import Blocks
+from gradio.components import (
+    Button,
+    Interpretation,
+    IOComponent,
+    Markdown,
+    State,
+    get_component_instance,
+)
+from gradio.data_classes import InterfaceTypes
+from gradio.documentation import document, set_documentation_group
+from gradio.events import Changeable, Streamable
+from gradio.flagging import CSVLogger, FlaggingCallback, FlagMethod
+from gradio.layouts import Column, Row, Tab, Tabs
+from gradio.pipelines import load_from_pipeline
+from gradio.themes import ThemeClass as Theme
+from gradio.utils import GRADIO_VERSION
+
+set_documentation_group("interface")
+
+if TYPE_CHECKING:  # Only import for type checking (is False at runtime).
+    from transformers.pipelines.base import Pipeline
+
+
+@document("launch", "load", "from_pipeline", "integrate", "queue")
+class Interface(Blocks):
+    """
+    Interface is Gradio's main high-level class, and allows you to create a web-based GUI / demo
+    around a machine learning model (or any Python function) in a few lines of code.
+    You must specify three parameters: (1) the function to create a GUI for (2) the desired input components and
+    (3) the desired output components. Additional parameters can be used to control the appearance
+    and behavior of the demo.
+
+    Example:
+        import gradio as gr
+
+        def image_classifier(inp):
+            return {'cat': 0.3, 'dog': 0.7}
+
+        demo = gr.Interface(fn=image_classifier, inputs="image", outputs="label")
+        demo.launch()
+    Demos: hello_world, hello_world_3, gpt_j
+    Guides: quickstart, key_features, sharing_your_app, interface_state, reactive_interfaces, advanced_interface_features, setting_up_a_gradio_demo_for_maximum_performance
+    """
+
+    # stores references to all currently existing Interface instances
+    instances: weakref.WeakSet = weakref.WeakSet()
+
+    @classmethod
+    def get_instances(cls) -> List[Interface]:
+        """
+        :return: list of all current instances.
+        """
+        return list(Interface.instances)
+
+    @classmethod
+    def load(
+        cls,
+        name: str,
+        src: str | None = None,
+        api_key: str | None = None,
+        alias: str | None = None,
+        **kwargs,
+    ) -> Interface:
+        """
+        Class method that constructs an Interface from a Hugging Face repo. Can accept
+        model repos (if src is "models") or Space repos (if src is "spaces"). The input
+        and output components are automatically loaded from the repo.
+        Parameters:
+            name: the name of the model (e.g. "gpt2" or "facebook/bart-base") or space (e.g. "flax-community/spanish-gpt2"), can include the `src` as prefix (e.g. "models/facebook/bart-base")
+            src: the source of the model: `models` or `spaces` (or leave empty if source is provided as a prefix in `name`)
+            api_key: optional access token for loading private Hugging Face Hub models or spaces. Find your token here: https://huggingface.co/settings/tokens
+            alias: optional string used as the name of the loaded model instead of the default name (only applies if loading a Space running Gradio 2.x)
+        Returns:
+            a Gradio Interface object for the given model
+        Example:
+            import gradio as gr
+            description = "Story generation with GPT"
+            examples = [["An adventurer is approached by a mysterious stranger in the tavern for a new quest."]]
+            demo = gr.Interface.load("models/EleutherAI/gpt-neo-1.3B", description=description, examples=examples)
+            demo.launch()
+        """
+        return super().load(name=name, src=src, api_key=api_key, alias=alias, **kwargs)
+
+    @classmethod
+    def from_pipeline(cls, pipeline: Pipeline, **kwargs) -> Interface:
+        """
+        Class method that constructs an Interface from a Hugging Face transformers.Pipeline object.
+        The input and output components are automatically determined from the pipeline.
+        Parameters:
+            pipeline: the pipeline object to use.
+        Returns:
+            a Gradio Interface object from the given Pipeline
+        Example:
+            import gradio as gr
+            from transformers import pipeline
+            pipe = pipeline("image-classification")
+            gr.Interface.from_pipeline(pipe).launch()
+        """
+        interface_info = load_from_pipeline(pipeline)
+        kwargs = dict(interface_info, **kwargs)
+        interface = cls(**kwargs)
+        return interface
+
+    def __init__(
+        self,
+        fn: Callable,
+        inputs: str | IOComponent | List[str | IOComponent] | None,
+        outputs: str | IOComponent | List[str | IOComponent] | None,
+        examples: List[Any] | List[List[Any]] | str | None = None,
+        cache_examples: bool | None = None,
+        examples_per_page: int = 10,
+        live: bool = False,
+        interpretation: Callable | str | None = None,
+        num_shap: float = 2.0,
+        title: str | None = None,
+        description: str | None = None,
+        article: str | None = None,
+        thumbnail: str | None = None,
+        theme: Theme | None = None,
+        css: str | None = None,
+        allow_flagging: str | None = None,
+        flagging_options: List[str] | List[Tuple[str, str]] | None = None,
+        flagging_dir: str = "flagged",
+        flagging_callback: FlaggingCallback = CSVLogger(),
+        analytics_enabled: bool | None = None,
+        batch: bool = False,
+        max_batch_size: int = 4,
+        _api_mode: bool = False,
+        **kwargs,
+    ):
+        """
+        Parameters:
+            fn: the function to wrap an interface around. Often a machine learning model's prediction function. Each parameter of the function corresponds to one input component, and the function should return a single value or a tuple of values, with each element in the tuple corresponding to one output component.
+            inputs: a single Gradio component, or list of Gradio components. Components can either be passed as instantiated objects, or referred to by their string shortcuts. The number of input components should match the number of parameters in fn. If set to None, then only the output components will be displayed.
+            outputs: a single Gradio component, or list of Gradio components. Components can either be passed as instantiated objects, or referred to by their string shortcuts. The number of output components should match the number of values returned by fn. If set to None, then only the input components will be displayed.
+            examples: sample inputs for the function; if provided, appear below the UI components and can be clicked to populate the interface. Should be nested list, in which the outer list consists of samples and each inner list consists of an input corresponding to each input component. A string path to a directory of examples can also be provided, but it should be within the directory with the python file running the gradio app. If there are multiple input components and a directory is provided, a log.csv file must be present in the directory to link corresponding inputs.
+            cache_examples: If True, caches examples in the server for fast runtime in examples. The default option in HuggingFace Spaces is True. The default option elsewhere is False.
+            examples_per_page: If examples are provided, how many to display per page.
+            live: whether the interface should automatically rerun if any of the inputs change.
+            interpretation: function that provides interpretation explaining prediction output. Pass "default" to use simple built-in interpreter, "shap" to use a built-in shapley-based interpreter, or your own custom interpretation function. For more information on the different interpretation methods, see the Advanced Interface Features guide.
+            num_shap: a multiplier that determines how many examples are computed for shap-based interpretation. Increasing this value will increase shap runtime, but improve results. Only applies if interpretation is "shap".
+            title: a title for the interface; if provided, appears above the input and output components in large font. Also used as the tab title when opened in a browser window.
+            description: a description for the interface; if provided, appears above the input and output components and beneath the title in regular font. Accepts Markdown and HTML content.
+            article: an expanded article explaining the interface; if provided, appears below the input and output components in regular font. Accepts Markdown and HTML content.
+            thumbnail: path or url to image to use as display image when the web demo is shared on social media.
+            theme: Theme to use, loaded from gradio.themes.
+            css: custom css or path to custom css file to use with interface.
+            allow_flagging: one of "never", "auto", or "manual". If "never" or "auto", users will not see a button to flag an input and output. If "manual", users will see a button to flag. If "auto", every input the user submits will be automatically flagged (outputs are not flagged). If "manual", both the input and outputs are flagged when the user clicks flag button. This parameter can be set with environmental variable GRADIO_ALLOW_FLAGGING; otherwise defaults to "manual".
+            flagging_options: if provided, allows user to select from the list of options when flagging. Only applies if allow_flagging is "manual". Can either be a list of tuples of the form (label, value), where label is the string that will be displayed on the button and value is the string that will be stored in the flagging CSV; or it can be a list of strings ["X", "Y"], in which case the values will be the list of strings and the labels will ["Flag as X", "Flag as Y"], etc.
+            flagging_dir: what to name the directory where flagged data is stored.
+            flagging_callback: An instance of a subclass of FlaggingCallback which will be called when a sample is flagged. By default logs to a local CSV file.
+            analytics_enabled: Whether to allow basic telemetry. If None, will use GRADIO_ANALYTICS_ENABLED environment variable if defined, or default to True.
+            batch: If True, then the function should process a batch of inputs, meaning that it should accept a list of input values for each parameter. The lists should be of equal length (and be up to length `max_batch_size`). The function is then *required* to return a tuple of lists (even if there is only 1 output component), with each list in the tuple corresponding to one output component.
+            max_batch_size: Maximum number of inputs to batch together if this is called from the queue (only relevant if batch=True)
+        """
+        super().__init__(
+            analytics_enabled=analytics_enabled,
+            mode="interface",
+            css=css,
+            title=title or "Gradio",
+            theme=theme,
+            **kwargs,
+        )
+
+        if isinstance(fn, list):
+            raise DeprecationWarning(
+                "The `fn` parameter only accepts a single function, support for a list "
+                "of functions has been deprecated. Please use gradio.mix.Parallel "
+                "instead."
+            )
+
+        self.interface_type = InterfaceTypes.STANDARD
+        if (inputs is None or inputs == []) and (outputs is None or outputs == []):
+            raise ValueError("Must provide at least one of `inputs` or `outputs`")
+        elif outputs is None or outputs == []:
+            outputs = []
+            self.interface_type = InterfaceTypes.INPUT_ONLY
+        elif inputs is None or inputs == []:
+            inputs = []
+            self.interface_type = InterfaceTypes.OUTPUT_ONLY
+
+        assert isinstance(inputs, (str, list, IOComponent))
+        assert isinstance(outputs, (str, list, IOComponent))
+
+        if not isinstance(inputs, list):
+            inputs = [inputs]
+        if not isinstance(outputs, list):
+            outputs = [outputs]
+
+        if self.is_space and cache_examples is None:
+            self.cache_examples = True
+        else:
+            self.cache_examples = cache_examples or False
+
+        state_input_indexes = [
+            idx for idx, i in enumerate(inputs) if i == "state" or isinstance(i, State)
+        ]
+        state_output_indexes = [
+            idx for idx, o in enumerate(outputs) if o == "state" or isinstance(o, State)
+        ]
+
+        if len(state_input_indexes) == 0 and len(state_output_indexes) == 0:
+            pass
+        elif len(state_input_indexes) != 1 or len(state_output_indexes) != 1:
+            raise ValueError(
+                "If using 'state', there must be exactly one state input and one state output."
+            )
+        else:
+            state_input_index = state_input_indexes[0]
+            state_output_index = state_output_indexes[0]
+            if inputs[state_input_index] == "state":
+                default = utils.get_default_args(fn)[state_input_index]
+                state_variable = State(value=default)  # type: ignore
+            else:
+                state_variable = inputs[state_input_index]
+
+            inputs[state_input_index] = state_variable
+            outputs[state_output_index] = state_variable
+
+            if cache_examples:
+                warnings.warn(
+                    "Cache examples cannot be used with state inputs and outputs."
+                    "Setting cache_examples to False."
+                )
+            self.cache_examples = False
+
+        self.input_components = [
+            get_component_instance(i, render=False) for i in inputs
+        ]
+        self.output_components = [
+            get_component_instance(o, render=False) for o in outputs
+        ]
+
+        for component in self.input_components + self.output_components:
+            if not (isinstance(component, IOComponent)):
+                raise ValueError(
+                    f"{component} is not a valid input/output component for Interface."
+                )
+
+        if len(self.input_components) == len(self.output_components):
+            same_components = [
+                i is o for i, o in zip(self.input_components, self.output_components)
+            ]
+            if all(same_components):
+                self.interface_type = InterfaceTypes.UNIFIED
+
+        if self.interface_type in [
+            InterfaceTypes.STANDARD,
+            InterfaceTypes.OUTPUT_ONLY,
+        ]:
+            for o in self.output_components:
+                assert isinstance(o, IOComponent)
+                o.interactive = False  # Force output components to be non-interactive
+
+        if (
+            interpretation is None
+            or isinstance(interpretation, list)
+            or callable(interpretation)
+        ):
+            self.interpretation = interpretation
+        elif isinstance(interpretation, str):
+            self.interpretation = [
+                interpretation.lower() for _ in self.input_components
+            ]
+        else:
+            raise ValueError("Invalid value for parameter: interpretation")
+
+        self.api_mode = _api_mode
+        self.fn = fn
+        self.fn_durations = [0, 0]
+        self.__name__ = getattr(fn, "__name__", "fn")
+        self.live = live
+        self.title = title
+
+        CLEANER = re.compile("<.*?>")
+
+        def clean_html(raw_html):
+            cleantext = re.sub(CLEANER, "", raw_html)
+            return cleantext
+
+        md = utils.get_markdown_parser()
+        simple_description = None
+        if description is not None:
+            description = md.render(description)
+            simple_description = clean_html(description)
+        self.simple_description = simple_description
+        self.description = description
+        if article is not None:
+            article = utils.readme_to_html(article)
+            article = md.render(article)
+        self.article = article
+
+        self.thumbnail = thumbnail
+        self.theme = theme
+
+        self.examples = examples
+        self.num_shap = num_shap
+        self.examples_per_page = examples_per_page
+
+        self.simple_server = None
+
+        # For allow_flagging: (1) first check for parameter,
+        # (2) check for env variable, (3) default to True/"manual"
+        if allow_flagging is None:
+            allow_flagging = os.getenv("GRADIO_ALLOW_FLAGGING", "manual")
+        if allow_flagging is True:
+            warnings.warn(
+                "The `allow_flagging` parameter in `Interface` now"
+                "takes a string value ('auto', 'manual', or 'never')"
+                ", not a boolean. Setting parameter to: 'manual'."
+            )
+            self.allow_flagging = "manual"
+        elif allow_flagging == "manual":
+            self.allow_flagging = "manual"
+        elif allow_flagging is False:
+            warnings.warn(
+                "The `allow_flagging` parameter in `Interface` now"
+                "takes a string value ('auto', 'manual', or 'never')"
+                ", not a boolean. Setting parameter to: 'never'."
+            )
+            self.allow_flagging = "never"
+        elif allow_flagging == "never":
+            self.allow_flagging = "never"
+        elif allow_flagging == "auto":
+            self.allow_flagging = "auto"
+        else:
+            raise ValueError(
+                "Invalid value for `allow_flagging` parameter."
+                "Must be: 'auto', 'manual', or 'never'."
+            )
+
+        if flagging_options is None:
+            self.flagging_options = [("Flag", "")]
+        elif not (isinstance(flagging_options, list)):
+            raise ValueError(
+                "flagging_options must be a list of strings or list of (string, string) tuples."
+            )
+        elif all([isinstance(x, str) for x in flagging_options]):
+            self.flagging_options = [(f"Flag as {x}", x) for x in flagging_options]
+        elif all([isinstance(x, tuple) for x in flagging_options]):
+            self.flagging_options = flagging_options
+        else:
+            raise ValueError(
+                "flagging_options must be a list of strings or list of (string, string) tuples."
+            )
+
+        self.flagging_callback = flagging_callback
+        self.flagging_dir = flagging_dir
+        self.batch = batch
+        self.max_batch_size = max_batch_size
+
+        self.save_to = None  # Used for selenium tests
+        self.share = None
+        self.share_url = None
+        self.local_url = None
+
+        self.favicon_path = None
+
+        if self.analytics_enabled:
+            data = {
+                "mode": self.mode,
+                "fn": fn,
+                "inputs": inputs,
+                "outputs": outputs,
+                "live": live,
+                "interpretation": interpretation,
+                "allow_flagging": allow_flagging,
+                "custom_css": self.css is not None,
+                "theme": self.theme,
+                "version": GRADIO_VERSION,
+            }
+            utils.initiated_analytics(data)
+
+        utils.version_check()
+        Interface.instances.add(self)
+
+        param_names = inspect.getfullargspec(self.fn)[0]
+        if len(param_names) > 0 and inspect.ismethod(self.fn):
+            param_names = param_names[1:]
+        for component, param_name in zip(self.input_components, param_names):
+            assert isinstance(component, IOComponent)
+            if component.label is None:
+                component.label = param_name
+        for i, component in enumerate(self.output_components):
+            assert isinstance(component, IOComponent)
+            if component.label is None:
+                if len(self.output_components) == 1:
+                    component.label = "output"
+                else:
+                    component.label = "output " + str(i)
+
+        if self.allow_flagging != "never":
+            if (
+                self.interface_type == InterfaceTypes.UNIFIED
+                or self.allow_flagging == "auto"
+            ):
+                self.flagging_callback.setup(self.input_components, self.flagging_dir)  # type: ignore
+            elif self.interface_type == InterfaceTypes.INPUT_ONLY:
+                pass
+            else:
+                self.flagging_callback.setup(
+                    self.input_components + self.output_components, self.flagging_dir  # type: ignore
+                )
+
+        # Render the Gradio UI
+        with self:
+            self.render_title_description()
+
+            submit_btn, clear_btn, stop_btn, flag_btns = None, None, None, None
+            interpretation_btn, interpretation_set = None, None
+            input_component_column, interpret_component_column = None, None
+
+            with Row().style(equal_height=False):
+                if self.interface_type in [
+                    InterfaceTypes.STANDARD,
+                    InterfaceTypes.INPUT_ONLY,
+                    InterfaceTypes.UNIFIED,
+                ]:
+                    (
+                        submit_btn,
+                        clear_btn,
+                        stop_btn,
+                        flag_btns,
+                        input_component_column,
+                        interpret_component_column,
+                        interpretation_set,
+                    ) = self.render_input_column()
+                if self.interface_type in [
+                    InterfaceTypes.STANDARD,
+                    InterfaceTypes.OUTPUT_ONLY,
+                ]:
+                    (
+                        submit_btn_out,
+                        clear_btn_2_out,
+                        stop_btn_2_out,
+                        flag_btns_out,
+                        interpretation_btn,
+                    ) = self.render_output_column(submit_btn)
+                    submit_btn = submit_btn or submit_btn_out
+                    clear_btn = clear_btn or clear_btn_2_out
+                    stop_btn = stop_btn or stop_btn_2_out
+                    flag_btns = flag_btns or flag_btns_out
+
+            assert clear_btn is not None, "Clear button not rendered"
+
+            self.attach_submit_events(submit_btn, stop_btn)
+            self.attach_clear_events(
+                clear_btn, input_component_column, interpret_component_column
+            )
+            self.attach_interpretation_events(
+                interpretation_btn,
+                interpretation_set,
+                input_component_column,
+                interpret_component_column,
+            )
+
+            self.attach_flagging_events(flag_btns, clear_btn)
+            self.render_examples()
+            self.render_article()
+
+        self.config = self.get_config_file()
+
+    def render_title_description(self) -> None:
+        if self.title:
+            Markdown(
+                "<h1 style='text-align: center; margin-bottom: 1rem'>"
+                + self.title
+                + "</h1>"
+            )
+        if self.description:
+            Markdown(self.description)
+
+    def render_flag_btns(self) -> List[Button]:
+        return [Button(label) for label, _ in self.flagging_options]
+
+    def render_input_column(
+        self,
+    ) -> Tuple[
+        Button | None,
+        Button | None,
+        Button | None,
+        List[Button] | None,
+        Column,
+        Column | None,
+        List[Interpretation] | None,
+    ]:
+        submit_btn, clear_btn, stop_btn, flag_btns = None, None, None, None
+        interpret_component_column, interpretation_set = None, None
+
+        with Column(variant="panel"):
+            input_component_column = Column()
+            with input_component_column:
+                for component in self.input_components:
+                    component.render()
+            if self.interpretation:
+                interpret_component_column = Column(visible=False)
+                interpretation_set = []
+                with interpret_component_column:
+                    for component in self.input_components:
+                        interpretation_set.append(Interpretation(component))
+            with Row():
+                if self.interface_type in [
+                    InterfaceTypes.STANDARD,
+                    InterfaceTypes.INPUT_ONLY,
+                ]:
+                    clear_btn = Button("Clear")
+                    if not self.live:
+                        submit_btn = Button("Submit", variant="primary")
+                        # Stopping jobs only works if the queue is enabled
+                        # We don't know if the queue is enabled when the interface
+                        # is created. We use whether a generator function is provided
+                        # as a proxy of whether the queue will be enabled.
+                        # Using a generator function without the queue will raise an error.
+                        if inspect.isgeneratorfunction(self.fn):
+                            stop_btn = Button("Stop", variant="stop", visible=False)
+                elif self.interface_type == InterfaceTypes.UNIFIED:
+                    clear_btn = Button("Clear")
+                    submit_btn = Button("Submit", variant="primary")
+                    if inspect.isgeneratorfunction(self.fn) and not self.live:
+                        stop_btn = Button("Stop", variant="stop")
+                    if self.allow_flagging == "manual":
+                        flag_btns = self.render_flag_btns()
+                    elif self.allow_flagging == "auto":
+                        flag_btns = [submit_btn]
+        return (
+            submit_btn,
+            clear_btn,
+            stop_btn,
+            flag_btns,
+            input_component_column,
+            interpret_component_column,
+            interpretation_set,
+        )
+
+    def render_output_column(
+        self,
+        submit_btn_in: Button | None,
+    ) -> Tuple[Button | None, Button | None, Button | None, List | None, Button | None]:
+        submit_btn = submit_btn_in
+        interpretation_btn, clear_btn, flag_btns, stop_btn = None, None, None, None
+
+        with Column(variant="panel"):
+            for component in self.output_components:
+                if not (isinstance(component, State)):
+                    component.render()
+            with Row():
+                if self.interface_type == InterfaceTypes.OUTPUT_ONLY:
+                    clear_btn = Button("Clear")
+                    submit_btn = Button("Generate", variant="primary")
+                    if inspect.isgeneratorfunction(self.fn) and not self.live:
+                        # Stopping jobs only works if the queue is enabled
+                        # We don't know if the queue is enabled when the interface
+                        # is created. We use whether a generator function is provided
+                        # as a proxy of whether the queue will be enabled.
+                        # Using a generator function without the queue will raise an error.
+                        stop_btn = Button("Stop", variant="stop", visible=False)
+                if self.allow_flagging == "manual":
+                    flag_btns = self.render_flag_btns()
+                elif self.allow_flagging == "auto":
+                    assert submit_btn is not None, "Submit button not rendered"
+                    flag_btns = [submit_btn]
+                if self.interpretation:
+                    interpretation_btn = Button("Interpret")
+
+        return submit_btn, clear_btn, stop_btn, flag_btns, interpretation_btn
+
+    def render_article(self):
+        if self.article:
+            Markdown(self.article)
+
+    def attach_submit_events(self, submit_btn: Button | None, stop_btn: Button | None):
+        if self.live:
+            if self.interface_type == InterfaceTypes.OUTPUT_ONLY:
+                assert submit_btn is not None, "Submit button not rendered"
+                super().load(self.fn, None, self.output_components)
+                # For output-only interfaces, the user probably still want a "generate"
+                # button even if the Interface is live
+                submit_btn.click(
+                    self.fn,
+                    None,
+                    self.output_components,
+                    api_name="predict",
+                    preprocess=not (self.api_mode),
+                    postprocess=not (self.api_mode),
+                    batch=self.batch,
+                    max_batch_size=self.max_batch_size,
+                )
+            else:
+                for component in self.input_components:
+                    if isinstance(component, Streamable) and component.streaming:
+                        component.stream(
+                            self.fn,
+                            self.input_components,
+                            self.output_components,
+                            api_name="predict",
+                            preprocess=not (self.api_mode),
+                            postprocess=not (self.api_mode),
+                        )
+                        continue
+                    if isinstance(component, Changeable):
+                        component.change(
+                            self.fn,
+                            self.input_components,
+                            self.output_components,
+                            api_name="predict",
+                            preprocess=not (self.api_mode),
+                            postprocess=not (self.api_mode),
+                        )
+        else:
+            assert submit_btn is not None, "Submit button not rendered"
+            fn = self.fn
+            extra_output = []
+            if stop_btn:
+
+                # Wrap the original function to show/hide the "Stop" button
+                def fn(*args):
+                    # The main idea here is to call the original function
+                    # and append some updates to keep the "Submit" button
+                    # hidden and the "Stop" button visible
+                    # The 'finally' block hides the "Stop" button and
+                    # shows the "submit" button. Having a 'finally' block
+                    # will make sure the UI is "reset" even if there is an exception
+                    try:
+                        for output in self.fn(*args):
+                            if len(self.output_components) == 1 and not self.batch:
+                                output = [output]
+                            output = [o for o in output]
+                            yield output + [
+                                Button.update(visible=False),
+                                Button.update(visible=True),
+                            ]
+                    finally:
+                        yield [
+                            {"__type__": "generic_update"}
+                            for _ in self.output_components
+                        ] + [Button.update(visible=True), Button.update(visible=False)]
+
+                extra_output = [submit_btn, stop_btn]
+            pred = submit_btn.click(
+                fn,
+                self.input_components,
+                self.output_components + extra_output,
+                api_name="predict",
+                scroll_to_output=True,
+                preprocess=not (self.api_mode),
+                postprocess=not (self.api_mode),
+                batch=self.batch,
+                max_batch_size=self.max_batch_size,
+            )
+            if stop_btn:
+                submit_btn.click(
+                    lambda: (
+                        submit_btn.update(visible=False),
+                        stop_btn.update(visible=True),
+                    ),
+                    inputs=None,
+                    outputs=[submit_btn, stop_btn],
+                    queue=False,
+                )
+                stop_btn.click(
+                    lambda: (
+                        submit_btn.update(visible=True),
+                        stop_btn.update(visible=False),
+                    ),
+                    inputs=None,
+                    outputs=[submit_btn, stop_btn],
+                    cancels=[pred],
+                    queue=False,
+                )
+
+    def attach_clear_events(
+        self,
+        clear_btn: Button,
+        input_component_column: Column | None,
+        interpret_component_column: Column | None,
+    ):
+        clear_btn.click(
+            None,
+            [],
+            (
+                self.input_components
+                + self.output_components
+                + ([input_component_column] if input_component_column else [])
+                + ([interpret_component_column] if self.interpretation else [])
+            ),  # type: ignore
+            _js=f"""() => {json.dumps(
+                [getattr(component, "cleared_value", None)
+                    for component in self.input_components + self.output_components] + (
+                    [Column.update(visible=True)]
+                    if self.interface_type
+                        in [
+                            InterfaceTypes.STANDARD,
+                            InterfaceTypes.INPUT_ONLY,
+                            InterfaceTypes.UNIFIED,
+                        ]
+                    else []
+                )
+                + ([Column.update(visible=False)] if self.interpretation else [])
+            )}
+            """,
+        )
+
+    def attach_interpretation_events(
+        self,
+        interpretation_btn: Button | None,
+        interpretation_set: List[Interpretation] | None,
+        input_component_column: Column | None,
+        interpret_component_column: Column | None,
+    ):
+        if interpretation_btn:
+            interpretation_btn.click(
+                self.interpret_func,
+                inputs=self.input_components + self.output_components,
+                outputs=(interpretation_set or []) + [input_component_column, interpret_component_column],  # type: ignore
+                preprocess=False,
+            )
+
+    def attach_flagging_events(self, flag_btns: List[Button] | None, clear_btn: Button):
+        if flag_btns:
+            if self.interface_type in [
+                InterfaceTypes.STANDARD,
+                InterfaceTypes.OUTPUT_ONLY,
+                InterfaceTypes.UNIFIED,
+            ]:
+                if self.allow_flagging == "auto":
+                    flag_method = FlagMethod(
+                        self.flagging_callback, "", "", visual_feedback=False
+                    )
+                    flag_btns[0].click(  # flag_btns[0] is just the "Submit" button
+                        flag_method,
+                        inputs=self.input_components,
+                        outputs=None,
+                        preprocess=False,
+                        queue=False,
+                    )
+                    return
+
+                if self.interface_type == InterfaceTypes.UNIFIED:
+                    flag_components = self.input_components
+                else:
+                    flag_components = self.input_components + self.output_components
+
+                for flag_btn, (label, value) in zip(flag_btns, self.flagging_options):
+                    assert isinstance(value, str)
+                    flag_method = FlagMethod(self.flagging_callback, label, value)
+                    flag_btn.click(
+                        lambda: Button.update(value="Saving...", interactive=False),
+                        None,
+                        flag_btn,
+                        queue=False,
+                    )
+                    flag_btn.click(
+                        flag_method,
+                        inputs=flag_components,
+                        outputs=flag_btn,
+                        preprocess=False,
+                        queue=False,
+                    )
+                    clear_btn.click(
+                        flag_method.reset,
+                        None,
+                        flag_btn,
+                        queue=False,
+                    )
+
+    def render_examples(self):
+        if self.examples:
+            non_state_inputs = [
+                c for c in self.input_components if not isinstance(c, State)
+            ]
+            non_state_outputs = [
+                c for c in self.output_components if not isinstance(c, State)
+            ]
+            self.examples_handler = Examples(
+                examples=self.examples,
+                inputs=non_state_inputs,  # type: ignore
+                outputs=non_state_outputs,  # type: ignore
+                fn=self.fn,
+                cache_examples=self.cache_examples,
+                examples_per_page=self.examples_per_page,
+                _api_mode=self.api_mode,
+                batch=self.batch,
+            )
+
+    def __str__(self):
+        return self.__repr__()
+
+    def __repr__(self):
+        repr = f"Gradio Interface for: {self.__name__}"
+        repr += "\n" + "-" * len(repr)
+        repr += "\ninputs:"
+        for component in self.input_components:
+            repr += "\n|-{}".format(str(component))
+        repr += "\noutputs:"
+        for component in self.output_components:
+            repr += "\n|-{}".format(str(component))
+        return repr
+
+    async def interpret_func(self, *args):
+        return await self.interpret(list(args)) + [
+            Column.update(visible=False),
+            Column.update(visible=True),
+        ]
+
+    async def interpret(self, raw_input: List[Any]) -> List[Any]:
+        return [
+            {"original": raw_value, "interpretation": interpretation}
+            for interpretation, raw_value in zip(
+                (await interpretation.run_interpret(self, raw_input))[0], raw_input
+            )
+        ]
+
+    def test_launch(self) -> None:
+        """
+        Deprecated.
+        """
+        warnings.warn("The Interface.test_launch() function is deprecated.")
+
+
+@document()
+class TabbedInterface(Blocks):
+    """
+    A TabbedInterface is created by providing a list of Interfaces, each of which gets
+    rendered in a separate tab.
+    Demos: stt_or_tts
+    """
+
+    def __init__(
+        self,
+        interface_list: List[Interface],
+        tab_names: List[str] | None = None,
+        title: str | None = None,
+        theme: Theme | None = None,
+        analytics_enabled: bool | None = None,
+        css: str | None = None,
+    ):
+        """
+        Parameters:
+            interface_list: a list of interfaces to be rendered in tabs.
+            tab_names: a list of tab names. If None, the tab names will be "Tab 1", "Tab 2", etc.
+            title: a title for the interface; if provided, appears above the input and output components in large font. Also used as the tab title when opened in a browser window.
+            analytics_enabled: whether to allow basic telemetry. If None, will use GRADIO_ANALYTICS_ENABLED environment variable or default to True.
+            css: custom css or path to custom css file to apply to entire Blocks
+        Returns:
+            a Gradio Tabbed Interface for the given interfaces
+        """
+        super().__init__(
+            title=title or "Gradio",
+            theme=theme,
+            analytics_enabled=analytics_enabled,
+            mode="tabbed_interface",
+            css=css,
+        )
+        if tab_names is None:
+            tab_names = ["Tab {}".format(i) for i in range(len(interface_list))]
+        with self:
+            if title:
+                Markdown(
+                    "<h1 style='text-align: center; margin-bottom: 1rem'>"
+                    + title
+                    + "</h1>"
+                )
+            with Tabs():
+                for (interface, tab_name) in zip(interface_list, tab_names):
+                    with Tab(label=tab_name):
+                        interface.render()
+
+
+def close_all(verbose: bool = True) -> None:
+    for io in Interface.get_instances():
+        io.close(verbose)